react-native-image-stitcher 0.16.0 → 0.16.2

package/cpp/stitcher.hpp

@@ -47,6 +47,23 @@
 #include <vector>
 
 
+// ── 2026-06-16 — memory-profiling compile gate (shared) ─────────────────
+// Hard gate for the peak sampler + per-stitch record + [memstat] phase logs
+// (stitcher.cpp) and the mallopt purge diagnostic READS (image_stitcher_jni.cpp).
+// Default: ON in debug, OFF in release, so production pays nothing.  Override
+// with -DRNIS_MEMORY_PROFILING=1 to profile a release build.  NDEBUG is the
+// portable signal both Gradle (Debug CMake config) and Xcode use, so this is
+// uniform across Android + iOS with no per-build-system flag.  Defined in the
+// shared header so all three native translation units agree.
+#ifndef RNIS_MEMORY_PROFILING
+#  ifdef NDEBUG
+#    define RNIS_MEMORY_PROFILING 0
+#  else
+#    define RNIS_MEMORY_PROFILING 1
+#  endif
+#endif
+
+
 namespace retailens {
 
 // Stable error codes.  Mirror the JS-side `StitchErrorCode` enum so
@@ -197,6 +214,23 @@ struct StitchConfig {
     // flip it to true once the manual port is verified — separate
     // commit from this V2 introduction.
     bool        useManualPipeline    = false;
+
+    // ── 2026-06-16 — memory profiling hooks (DEV deploy gate) ───────────
+    // memProbeFn: resident-memory source in MB, or < 0 if unavailable.  When
+    // set it is the canonical reader used by rss_mb() (so the OOM guards, the
+    // phase logs, the peak sampler and the per-stitch record all use it).  Its
+    // reason for existing is iOS, which has no /proc/self/statm — the Obj-C++
+    // bridge plugs task_info(TASK_VM_INFO).phys_footprint here.  Android leaves
+    // it null and rss_mb() falls back to /proc.  Must be callable from a
+    // background thread (the peak sampler), so the closure must not touch
+    // thread-affine state.
+    std::function<double()> memProbeFn = nullptr;
+    // enableMemoryProfiling: runtime gate (plumbed from settings.debug) for the
+    // peak sampler + the per-stitch record + the [memstat] phase logs.  The
+    // COMPILE-time RNIS_MEMORY_PROFILING flag (off in release) is the hard gate;
+    // this is the per-call switch on top.  The mallopt(M_PURGE) CALL is NOT
+    // gated by this — only its diagnostic READS are.
+    bool        enableMemoryProfiling = false;
 };
 
 
@@ -235,6 +269,24 @@ struct StitchResult {
     // Empty on builds that don't populate it (back-compat).  iOS marshals it up
     // to the JS finalize dict; Android leaves it in the log for now.
     std::string debugSummary;
+
+    // ── 2026-06-16 — per-stitch memory record (DEV profiling) ───────────
+    // All in MB; -1.0 when profiling is off or no memory source is available.
+    //   memBeforeMB: resident at entry (after the leak-fix once-guard).
+    //   memPeakMB:   max resident sampled DURING the stitch by the 50 ms peak
+    //                sampler — the transient warp-all + GraphCut + MultiBand
+    //                spike that the phase-boundary reads miss (it decides OOM).
+    //   memAfterMB:  resident after the pipeline returns (blender pyramids freed).
+    //   memFloorMB:  resident after the platform's post-stitch reclaim — Android
+    //                fills it after mallopt(M_PURGE); iOS after a settle read.
+    //                This is the leak-PLATEAU metric (the bridge sets it; the
+    //                core leaves it at -1).
+    //   memSource:   "phys_footprint" (iOS task_info) | "rss" (/proc) | "".
+    double      memBeforeMB = -1.0;
+    double      memPeakMB   = -1.0;
+    double      memAfterMB  = -1.0;
+    double      memFloorMB  = -1.0;
+    std::string memSource;
 };
 
 

package/dist/camera/Camera.d.ts

@@ -123,6 +123,19 @@ export type CameraCaptureResult = {
      * cv::Stitcher at finalize).
      */
     stitchModeResolved?: 'panorama' | 'scans';
+    /**
+     * 2026-06-15 (DEV) — gyro rotation magnitude of the capture, in radians.
+     * Shown on the dev preview so the panorama-vs-SCANS rotation threshold can
+     * be tuned. `0` = no pose-derived rotation signal (non-AR with no poses).
+     */
+    rRadians?: number;
+    /**
+     * 2026-06-16 (DEV) — translation magnitude (m) + auto decision ratio
+     * (`>=0.55` → SCANS) that drove panorama-vs-SCANS. Shown on the dev
+     * readout alongside `rRadians` to tune the threshold from real captures.
+     */
+    tMeters?: number;
+    decisionRatio?: number;
     /**
      * 2026-06-14 (DEV overlay) — semicolon-separated `key=value` trace of the
      * stitcher's runtime choices (pipe/warp/route/seam/blend) for this

package/dist/camera/Camera.js

@@ -379,58 +379,6 @@ function Camera(props) {
     // CameraCaptureResult we'd otherwise have emitted, stashed so cancel /
     // crop-confirm can emit it (possibly with cropped dims) afterwards.
     const [cropPending, setCropPending] = (0, react_1.useState)(null);
-    // 2026-06-15 — ON-DEMAND high-level preview.  Manual is the default/eager
-    // output; when the user switches to the "high-level" tab in the preview we
-    // re-stitch the SAME captured keyframes through stock cv::Stitcher via
-    // `refinePanorama` (useManualPipeline:false).  Resolves with the high-level
-    // JPEG's file:// uri AND its OWN DEV-overlay recipe (so the preview pill shows
-    // the high-level recipe — pipe=highlevel;… — while that tab is viewed, not the
-    // manual primary's recipe), or null when unavailable (no keyframe paths —
-    // e.g. Android — or the stitch failed).  Computed lazily so it costs nothing
-    // unless the user actually asks for it.
-    const requestHighLevelAlt = (0, react_1.useCallback)(async () => {
-        const pending = cropPending;
-        const kf = pending?.captureResultObj.keyframePaths;
-        if (!pending || !kf || kf.length < 2)
-            return null;
-        const native = (0, incremental_1.getIncrementalNativeModule)();
-        if (!native)
-            return null;
-        const outputPath = `${(0, paths_1.toBareFilePath)(pending.uri).replace(/\.jpg$/i, '')}-highlevel.jpg`;
-        try {
-            const r = await native.refinePanorama({
-                framePaths: kf,
-                outputPath,
-                config: {
-                    useManualPipeline: false,
-                    warperType: 'spherical',
-                    stitchMode: 'panorama',
-                    // Match the manual output's rotation — without this the high-level
-                    // re-stitch bakes "portrait" (no rotation) and comes out sideways.
-                    captureOrientation: pending.captureResultObj.captureOrientation,
-                },
-            });
-            // Plain file:// uri — the path is unique per capture and computed once, so
-            // no cache-bust here (the accept handler adds one when emitting).  The
-            // DEV pill text is the HIGH-LEVEL stitch's own recipe (only the fields
-            // IncrementalRefineResult carries; buildStitchDebugInfo tolerates the rest
-            // being absent).
-            return {
-                uri: (0, paths_1.toFileUri)(r.panoramaPath),
-                debugInfo: (0, stitchDebugInfo_1.buildStitchDebugInfo)({
-                    debugSummary: r.debugSummary,
-                    finalConfidenceThresh: r.finalConfidenceThresh,
-                    framesIncluded: r.framesIncluded,
-                    framesRequested: r.framesRequested,
-                    width: r.width,
-                    height: r.height,
-                }),
-            };
-        }
-        catch {
-            return null;
-        }
-    }, [cropPending]);
     // 2026-05-22 (audit F9 + F3) — debug stitch-stats toast.  Hook
     // exposes an imperative API; we fire `showResult(finalizeResult)`
     // on every successful finalize when settings.debug is on (gated
@@ -1140,7 +1088,7 @@ function Camera(props) {
             // native side uses pose-derived translation and ignores this).
             const imuTotalTranslationM = isNonAR ? imuGate.getTotalAbsMetres() : 0;
             const result = await incremental.finalize(panoOutputPath, 90, // default JPEG quality
-            deviceOrientation, imuTotalTranslationM);
+            deviceOrientation, imuTotalTranslationM, lens);
             if (typeof result.framesRequested === 'number'
                 && typeof result.framesIncluded === 'number'
                 && result.framesIncluded < result.framesRequested) {
@@ -1174,6 +1122,9 @@ function Camera(props) {
                 finalConfidenceThresh: result.finalConfidenceThresh ?? -1,
                 durationMs: Date.now() - (recordingStartedAt ?? Date.now()),
                 stitchModeResolved: result.stitchModeResolved,
+                rRadians: result.rRadians,
+                tMeters: result.tMeters,
+                decisionRatio: result.decisionRatio,
                 debugSummary: result.debugSummary,
                 keyframePaths: result.batchKeyframePaths,
                 captureOrientation: result.captureOrientation,
@@ -1279,6 +1230,10 @@ function Camera(props) {
         isNonAR,
         imuGate,
         stitchToast,
+        // 2026-06-16 — the finalize passes `lens` (the high-level warper tree's zoom
+        // signal); without it here the closure would send a STALE lens if the user
+        // switched 1x↔0.5x after this callback was last memoized.
+        lens,
         // feature/pano-ux-guidance — the release also tears down the
         // pan-duration timer + a pending rotate-gate, and decides whether to
         // route the result through the crop editor.
@@ -1569,17 +1524,7 @@ function Camera(props) {
         , { 
             // Remount per capture so the dragged-quad + layout state re-seed to
             // the new image (RectCropPreview seeds its quad once via useState).
-            key: cropPending?.uri ?? 'crop', visible: cropPending != null, imageUri: cropPending?.uri ?? '', imageWidth: cropPending?.width ?? 0, imageHeight: cropPending?.height ?? 0, 
-            // 2026-06-15 — manual is the default/eager output.  The high-level tab
-            // is ON DEMAND: RectCropPreview calls onRequestAlt() (which re-stitches
-            // the captured keyframes via cv::Stitcher) only when the user switches
-            // to it.  DEBUG-ONLY: it's a pipeline-comparison tool (dev-jargon
-            // "Manual"/"High-level" labels), gated behind `settings.debug` like the
-            // rest of the diagnostic UI.  Also requires keyframePaths, so it only
-            // appears where it can run (iOS); Android returns no paths → no tab.
-            onRequestAlt: settings.debug && cropPending?.captureResultObj.keyframePaths?.length
-                ? requestHighLevelAlt
-                : undefined, initialRect: cropPending?.initialRect, warnings: cropPending?.warnings.map((w) => w.message) ?? [], showCropControls: rectCrop, topInset: insets.top, bottomInset: insets.bottom, copy: guidanceCopyResolved, 
+            key: cropPending?.uri ?? 'crop', visible: cropPending != null, imageUri: cropPending?.uri ?? '', imageWidth: cropPending?.width ?? 0, imageHeight: cropPending?.height ?? 0, initialRect: cropPending?.initialRect, warnings: cropPending?.warnings.map((w) => w.message) ?? [], showCropControls: rectCrop, topInset: insets.top, bottomInset: insets.bottom, copy: guidanceCopyResolved, 
             // Carry the live memory pill onto the preview too (same settings.debug
             // gate as the camera), so the operator can watch the RSS spike when the
             // on-demand high-level re-stitch fires.

package/dist/camera/CaptureFrameCounterOverlay.js

@@ -32,13 +32,24 @@ exports.topCenterForOrientation = topCenterForOrientation;
 const react_1 = __importDefault(require("react"));
 const react_native_1 = require("react-native");
 const guidanceTokens_1 = require("./guidanceTokens");
+/**
+ * Extra distance (px) to drop the counter from the user-top in landscape so it
+ * clears the pan how-to coach-mark's bouncing arrow.  Landscape only; portrait
+ * is unaffected.  72 px (the symmetric lift) over-cleared, so this is smaller.
+ */
+const COUNTER_LANDSCAPE_EXTRA_INSET = 40;
 function CaptureFrameCounterOverlay({ visible, framesCaptured, framesMax, orientation, style, }) {
     if (!visible || framesMax <= 0)
         return null;
     // Clamp the displayed numerator into [0, framesMax] — the engine can
     // briefly report the cap-th accept before the parent finalizes.
     const k = Math.max(0, Math.min(framesCaptured, framesMax));
-    const { container, rotate } = topCenterForOrientation(orientation, guidanceTokens_1.GUIDANCE_COUNTDOWN.inset);
+    // 2026-06-16 — in LANDSCAPE, push the counter further from the user-top so it
+    // clears the pan how-to coach-mark's bouncing amber arrow, which sits near the
+    // top there and otherwise overlaps it.  Portrait keeps the standard inset.
+    // Tune COUNTER_LANDSCAPE_EXTRA_INSET if the gap is too small / too large.
+    const isLandscape = orientation === 'landscape-left' || orientation === 'landscape-right';
+    const { container, rotate } = topCenterForOrientation(orientation, guidanceTokens_1.GUIDANCE_COUNTDOWN.inset + (isLandscape ? COUNTER_LANDSCAPE_EXTRA_INSET : 0));
     return (react_1.default.createElement(react_native_1.View, { pointerEvents: "none", style: [styles.layer, container, style] },
         react_1.default.createElement(react_native_1.View, { style: [styles.pill, { transform: [{ rotate }] }] },
             react_1.default.createElement(react_native_1.View, { style: styles.dot }),

package/dist/camera/CaptureMemoryPill.d.ts

@@ -2,15 +2,23 @@
  * CaptureMemoryPill — top-right diagnostic pill showing native
  * process memory footprint in MB, polled at 500 ms.
  *
- * Color-coded against the iPhone 16 Pro per-process jetsam limit:
+ * Color-coded against the device's per-process memory budget, which is read
+ * once at mount via `getDeviceTotalRamMB()` (RAM-aware):
  *
- *   - green  <1500 MB   (comfortable)
- *   - amber  1500–2200  (approaching pressure)
- *   - red    >2200      (close to limit — capture may be killed)
+ *   budget = max(RAM × 0.42, 900 MB)   (mirrors warp_guard.hpp
+ *                                        perProcessMemoryBudgetMB)
+ *   - green  < 55 % of budget   (comfortable)
+ *   - amber  55–70 % of budget   (approaching pressure)
+ *   - red    > 70 % of budget    (close to limit — capture may be killed)
  *
- * Backed by the existing `getMemoryFootprintMB()` native module
- * (iOS: `task_info phys_footprint`, Android: `Debug.MemoryInfo
- * getTotalPss * 1024`).  Returns -1 if the native call fails.
+ * Why RAM-aware: the old fixed 1500/2200 MB thresholds were tuned for the
+ * iPhone 16 Pro and NEVER tripped on a 4 GB Android phone that jetsams ~1.3 GB
+ * (false comfort exactly where OOM happens).  Falls back to 1500/2200 if the
+ * RAM read is unavailable.
+ *
+ * Backed by the `getMemoryFootprintMB()` native module (iOS: `task_info`
+ * `phys_footprint`; Android: `/proc/self/statm` RSS — the SAME number the C++
+ * `[memstat]` logs report).  Returns -1 if the native call fails.
  *
  * Mount this pill inside a `settings.debug`-gated branch — it
  * polls native every 500 ms and is unwanted in production builds.

package/dist/camera/CaptureMemoryPill.js

@@ -4,15 +4,23 @@
  * CaptureMemoryPill — top-right diagnostic pill showing native
  * process memory footprint in MB, polled at 500 ms.
  *
- * Color-coded against the iPhone 16 Pro per-process jetsam limit:
+ * Color-coded against the device's per-process memory budget, which is read
+ * once at mount via `getDeviceTotalRamMB()` (RAM-aware):
  *
- *   - green  <1500 MB   (comfortable)
- *   - amber  1500–2200  (approaching pressure)
- *   - red    >2200      (close to limit — capture may be killed)
+ *   budget = max(RAM × 0.42, 900 MB)   (mirrors warp_guard.hpp
+ *                                        perProcessMemoryBudgetMB)
+ *   - green  < 55 % of budget   (comfortable)
+ *   - amber  55–70 % of budget   (approaching pressure)
+ *   - red    > 70 % of budget    (close to limit — capture may be killed)
  *
- * Backed by the existing `getMemoryFootprintMB()` native module
- * (iOS: `task_info phys_footprint`, Android: `Debug.MemoryInfo
- * getTotalPss * 1024`).  Returns -1 if the native call fails.
+ * Why RAM-aware: the old fixed 1500/2200 MB thresholds were tuned for the
+ * iPhone 16 Pro and NEVER tripped on a 4 GB Android phone that jetsams ~1.3 GB
+ * (false comfort exactly where OOM happens).  Falls back to 1500/2200 if the
+ * RAM read is unavailable.
+ *
+ * Backed by the `getMemoryFootprintMB()` native module (iOS: `task_info`
+ * `phys_footprint`; Android: `/proc/self/statm` RSS — the SAME number the C++
+ * `[memstat]` logs report).  Returns -1 if the native call fails.
  *
  * Mount this pill inside a `settings.debug`-gated branch — it
  * polls native every 500 ms and is unwanted in production builds.
@@ -57,11 +65,22 @@ const react_native_1 = require("react-native");
 const incremental_1 = require("../stitching/incremental");
 function CaptureMemoryPill({ topInset = 0, pollIntervalMs = 500, style, }) {
     const [memMB, setMemMB] = (0, react_1.useState)(null);
+    // Device total RAM (MB), read once — drives the RAM-aware pressure bands.
+    const [ramMB, setRamMB] = (0, react_1.useState)(null);
     (0, react_1.useEffect)(() => {
         const native = (0, incremental_1.getIncrementalNativeModule)();
         if (!native?.getMemoryFootprintMB)
             return undefined;
         let cancelled = false;
+        // One-time RAM read for the bands (optional native method — older bridges
+        // without it just keep the fixed-threshold fallback).
+        native
+            .getDeviceTotalRamMB?.()
+            .then((r) => {
+            if (!cancelled && r > 0)
+                setRamMB(r);
+        })
+            .catch(() => { });
         const tick = async () => {
             try {
                 const mb = await native.getMemoryFootprintMB();
@@ -81,8 +100,14 @@ function CaptureMemoryPill({ topInset = 0, pollIntervalMs = 500, style, }) {
     }, [pollIntervalMs]);
     if (memMB === null || memMB < 0)
         return null;
-    const bg = memMB > 2200 ? 'rgba(239, 68, 68, 0.92)' // red
-        : memMB > 1500 ? 'rgba(245, 158, 11, 0.92)' // amber
+    // RAM-aware bands: budget = max(RAM × 0.42, 900) (mirrors warp_guard.hpp
+    // perProcessMemoryBudgetMB); amber at 55 %, red at 70 %.  Fall back to the
+    // iPhone-tuned fixed thresholds when RAM is unknown.
+    const budget = ramMB != null ? Math.max(ramMB * 0.42, 900) : null;
+    const redAt = budget != null ? budget * 0.7 : 2200;
+    const amberAt = budget != null ? budget * 0.55 : 1500;
+    const bg = memMB > redAt ? 'rgba(239, 68, 68, 0.92)' // red
+        : memMB > amberAt ? 'rgba(245, 158, 11, 0.92)' // amber
             : 'rgba(34, 197, 94, 0.92)'; // green
     return (react_1.default.createElement(react_native_1.View, { pointerEvents: "none", style: [
             styles.container,

package/dist/camera/PanoramaBandOverlay.d.ts

@@ -190,6 +190,7 @@ declare function tileRotation(orientation: BandCaptureOrientation, vertical: boo
 export declare const _bandThumbRotationForTests: typeof bandThumbRotation;
 /** @internal test-only export — see `tileRotation`. */
 export declare const _tileRotationForTests: typeof tileRotation;
-export declare function PanoramaBandOverlay({ state, frameUris, captureOrientation, vertical, }: PanoramaBandOverlayProps): React.JSX.Element | null;
+declare function PanoramaBandOverlayImpl({ state, frameUris, captureOrientation, vertical, }: PanoramaBandOverlayProps): React.JSX.Element | null;
+export declare const PanoramaBandOverlay: React.MemoExoticComponent<typeof PanoramaBandOverlayImpl>;
 export {};
 //# sourceMappingURL=PanoramaBandOverlay.d.ts.map

package/dist/camera/PanoramaBandOverlay.js

@@ -92,8 +92,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._tileRotationForTests = exports._bandThumbRotationForTests = void 0;
-exports.PanoramaBandOverlay = PanoramaBandOverlay;
+exports.PanoramaBandOverlay = exports._tileRotationForTests = exports._bandThumbRotationForTests = void 0;
 const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
 // ── Layout constants — tuned to read clearly at arm's length ────────
@@ -295,7 +294,7 @@ function layoutFor(orientation, vertical) {
         arrowGlyph: '→',
     };
 }
-function PanoramaBandOverlay({ state, frameUris, captureOrientation, vertical = false, }) {
+function PanoramaBandOverlayImpl({ state, frameUris, captureOrientation, vertical = false, }) {
     // 2026-05-18 (Issue #3 fix) — orientation source priority:
     //   1. `captureOrientation` prop from the host (4-way; correct
     //      for landscape-left vs landscape-right disambiguation).
@@ -456,6 +455,13 @@ function PanoramaBandOverlay({ state, frameUris, captureOrientation, vertical =
         react_1.default.createElement(react_native_1.View, { style: styles.arrowTrack },
             react_1.default.createElement(react_native_1.Text, { style: styles.arrowGlyph }, layout.arrowGlyph))))));
 }
+// 2026-06-16 (audit #7) — memoized.  This is the lone ~6 Hz consumer that mounts
+// in PRODUCTION (the debug pills are settings.debug-gated), and most engine ticks
+// are REJECTED frames that don't change its visible inputs (frameUris /
+// acceptedCount / orientation).  React.memo skips the re-render on those, so the
+// ~6×/sec engine emits no longer re-render this overlay's subtree on the hot
+// capture path (battery/heat on long captures).
+exports.PanoramaBandOverlay = react_1.default.memo(PanoramaBandOverlayImpl);
 const styles = react_native_1.StyleSheet.create({
     // Properties common to every layout — uniform border-radius so the
     // band reads as a single capsule regardless of which edge it's

package/dist/camera/PanoramaSettings.js

@@ -77,21 +77,19 @@ exports.DEFAULT_PANORAMA_SETTINGS = {
     captureSource: 'ar',
     debug: false,
     stitcher: {
-        // v0.16 — PANORAMA by default (was 'auto').  The auto-resolver's SCANS
-        // branch leans on double-integrated IMU translation, which is unreliable
-        // during rotation (gravity leakage inflates the translation estimate); in
-        // practice rotational pans are the common case and resolve to panorama
-        // anyway.  Defaulting to panorama is the robust choice — host apps that
-        // genuinely capture flat documents/walls can still opt into 'auto' or
-        // 'scans' via the ⚙️ panel or the `defaultStitchMode` / `stitcher` props.
-        stitchMode: 'panorama',
-        // v0.16 — SPHERICAL by default (bounds both axes; the proven-robust wide/
-        // vertical-pan projection).  This is now the single source of truth — the
-        // native side no longer hardcodes a warper, so the ⚙️ panel + the host's
-        // `defaultWarper` prop actually take effect.  Note: choosing `plane` here
-        // re-arms the dynamic plane→spherical fallback/divergence switch in the
-        // manual pipeline (it only fires when warperType != spherical).
-        warperType: 'spherical',
+        // v0.16 — AUTO by default.  Reverted from the brief 'panorama' default after
+        // on-device comparison (matches the v0.15.2 behaviour, which produced better
+        // results for these captures).  The auto-resolver now carries the
+        // low-rotation guard (rRadians>0.35 && t<0.25 → force PANORAMA), so the old
+        // IMU-gravity-leak SCANS misclassification on rotational pans is fixed; auto
+        // can again safely pick SCANS (high-level affine) for genuine flat scans.
+        stitchMode: 'auto',
+        // v0.16 — PLANE by default.  Reverted from 'spherical' after on-device
+        // comparison (matches v0.15.2 — flatter, more natural for the common 1x
+        // pan).  Plane is unbounded, so this re-arms the manual pipeline's dynamic
+        // plane→SPHERICAL divergence/quality fallback (it fires only when
+        // warperType != 'spherical'), keeping wide/off-axis pans safe.
+        warperType: 'plane',
         blenderType: 'multiband',
         seamFinderType: 'graphcut',
         // v0.15 — inscribed-rect crop is OFF by default (bbox crop keeps all
@@ -102,16 +100,15 @@ exports.DEFAULT_PANORAMA_SETTINGS = {
     },
     frameSelection: {
         mode: 'flow-based',
-        // v0.16 — denser keyframes by default: a 15% novelty gate, up to 8 frames,
-        // plus a 1.5 s time-budget force-accept (so a slow/static pan still lands a
-        // keyframe every 1.5 s even when novelty is low).  With 8 frames this bounds
-        // a static/slow capture to ~8×1.5 ≈ 12 s before the keyframe-count
-        // auto-finalize.  More overlap between consecutive keyframes ⇒ stronger
-        // feature matching ⇒ more robust registration.  Memory-checked: 8 frames fit
-        // the BATCH held-set cap on both platforms.  Overlap selectable in the
-        // settings panel {10,15,20,30}% (native clamp floor 10%); cap clamps [3,10].
-        maxKeyframes: 8,
-        overlapThreshold: 0.15,
+        // v0.16 — keyframe gate: a 20% novelty gate, up to 6 frames, plus a 1.5 s
+        // time-budget force-accept (so a slow/static pan still lands a keyframe every
+        // 1.5 s even when novelty is low).  These match the leaner v0.15.2 cadence (6
+        // frames / 20% overlap) — fewer, more-novel keyframes = lighter memory + less
+        // redundant overlap.  With 6 frames this bounds a static/slow capture to
+        // ~6×1.5 ≈ 9 s before the keyframe-count auto-finalize.  Overlap selectable in
+        // the settings panel {10,15,20,30}% (native clamp floor 10%); cap clamps [3,10].
+        maxKeyframes: 6,
+        overlapThreshold: 0.20,
         maxKeyframeIntervalMs: 1500,
         flow: exports.DEFAULT_FLOW_GATE_SETTINGS,
     },

package/dist/camera/RectCropPreview.d.ts

@@ -67,32 +67,6 @@ export interface RectCropPreviewProps {
     imageWidth: number;
     /** Intrinsic pixel height of `imageUri`. */
     imageHeight: number;
-    /**
-     * DEBUG A/B harness — file:// URI of the SAME capture stitched by the
-     * OPPOSITE pipeline (manual cv::detail + plane).  When set, a toggle appears
-     * that flips the displayed panorama between the primary (high-level +
-     * spherical) and this one, for on-device comparison on a single capture.
-     * Its dimensions are read at runtime via `Image.getSize`.  When the manual
-     * output is showing, the crop quad is hidden and the accept button emits
-     * THIS uri (so you can pick the better pipeline per capture).
-     */
-    altImageUri?: string;
-    /**
-     * 2026-06-15 — ON-DEMAND alt (high-level) stitch.  The PRIMARY image is the
-     * MANUAL pipeline (the default output); this callback re-stitches the SAME
-     * captured keyframes via cv::Stitcher and resolves with a file:// uri (or
-     * null on failure).  It runs only the FIRST time the user taps the
-     * "High-level" tab — nothing is computed unless asked for.  When provided (or
-     * `altImageUri` is), the A/B toggle appears.
-     *
-     * Resolves with the high-level output's file:// `uri` AND its OWN
-     * DEV-overlay `debugInfo` recipe (so the params pill can switch to the
-     * high-level recipe while that tab is viewed), or `null` on failure.
-     */
-    onRequestAlt?: () => Promise<{
-        uri: string;
-        debugInfo: string;
-    } | null>;
     /** Show / hide the editor. */
     visible: boolean;
     /**
@@ -136,9 +110,9 @@ export interface RectCropPreviewProps {
     copy?: Partial<GuidanceCopy>;
     /**
      * Safe-area insets (px).  The editor is a full-screen Modal, so the host
-     * passes `insets.top`/`insets.bottom` to keep the top toolbar (A/B toggle,
-     * warnings) clear of the notch/Dynamic Island and the bottom button bar
-     * clear of the home indicator.  Default 0.
+     * passes `insets.top`/`insets.bottom` to keep the top toolbar (warnings)
+     * clear of the notch/Dynamic Island and the bottom button bar clear of the
+     * home indicator.  Default 0.
      */
     topInset?: number;
     bottomInset?: number;