react-native-image-stitcher 0.15.2 → 0.16.1

package/dist/camera/PanHowToOverlay.js

@@ -0,0 +1,222 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * PanHowToOverlay — the "how to pan" coach-mark (guidance item 3).
+ *
+ * Shown briefly at the START of a capture to teach the panning
+ * gesture before the live pan-speed pill (`PanoramaGuidance`) takes
+ * over.  It pairs the code-drawn `PanPhoneGraphic` (white phone +
+ * sweeping amber band) with a code-built bouncing arrow so the
+ * direction reads instantly without any copy.
+ *
+ *   ┌──────────────────────────────────────────────────────────┐
+ *   │                                                          │
+ *   │                  ┌───────────────┐                       │
+ *   │                  │  PanPhone     │   (240px graphic, the │
+ *   │                  │  Graphic      │    white phone +      │
+ *   │                  └───────────────┘    amber sweep)       │
+ *   │                         ▼  ← amber triangle              │
+ *   │                         ▼     bouncing ~12px along the   │
+ *   │                              pan axis, back and forth    │
+ *   └──────────────────────────────────────────────────────────┘
+ *
+ * Direction follows the capture mode (derived from the physical
+ * device orientation, sensor-based — works under portrait-lock):
+ *
+ *   Mode A — LANDSCAPE  → pan TOP → BOTTOM → arrow points DOWN.
+ *   Mode B — PORTRAIT   → pan LEFT → RIGHT → arrow points RIGHT.
+ *
+ * Both `landscape-left` and `landscape-right` are valid Mode A.
+ *
+ * ## Visibility & timing
+ *
+ * This component is intentionally pure-presentational: the PARENT
+ * owns `visible` and the brief auto-fade lifecycle (mount → show →
+ * dismiss once recording is under way).  We never self-time;
+ * `visible === false` renders `null` so the host can mount us
+ * unconditionally without layout shift.
+ *
+ * ## Upright under portrait-lock
+ *
+ * The app layout is typically portrait-locked, so when the user
+ * holds the device in landscape (Mode A) the JS framebuffer is NOT
+ * rotated.  We counter-rotate the whole coach-mark with
+ * `useContentRotation()` (same hook the bottom controls use) so the
+ * graphic and arrow read upright relative to gravity.  The arrow's
+ * bounce axis and triangle point are expressed in that upright frame
+ * — i.e. the user's view — so "down" / "right" mean what the user
+ * sees, not the layout's raw axes.
+ *
+ * ## No SVG / no extra deps
+ *
+ * The arrow is a pure CSS border-width triangle (a zero-size View
+ * whose thick coloured border on one edge + transparent borders on
+ * the adjacent edges read as a filled triangle).  Bounce is a single
+ * `Animated.loop` on the native driver — cheap, and only running
+ * while `visible`.
+ */
+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.PanHowToOverlay = PanHowToOverlay;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const guidanceGraphics_1 = require("./guidanceGraphics");
+const guidanceTokens_1 = require("./guidanceTokens");
+const useContentRotation_1 = require("./useContentRotation");
+/** Distance (px) the arrow travels along the pan axis each bounce. */
+const BOUNCE_DISTANCE = 12;
+/** Half-period of the bounce (out, then back) — ~700 ms each leg. */
+const BOUNCE_DURATION_MS = 700;
+/** Visual size of the CSS-triangle arrow (base width / height in px). */
+const ARROW_SIZE = 18;
+/**
+ * Map a physical orientation to the pan direction the user should
+ * sweep.  Mode A (either landscape) pans top→bottom (DOWN); Mode B
+ * (either portrait variant) pans left→right (RIGHT).  Directions are
+ * in the user's upright view — the content wrapper is counter-rotated
+ * so these read correctly under portrait-lock.
+ */
+function directionForOrientation(orientation) {
+    switch (orientation) {
+        case 'landscape-left':
+        case 'landscape-right':
+            return 'down';
+        case 'portrait':
+        case 'portrait-upside-down':
+        default:
+            return 'right';
+    }
+}
+function PanHowToOverlay({ visible, orientation, style, }) {
+    // Counter-rotation so the GIF + arrow read upright relative to
+    // gravity even when the app is portrait-locked and the device is
+    // held in landscape (Mode A).  Always called so hook order is
+    // stable across the `visible` toggle.
+    const contentRotation = (0, useContentRotation_1.useContentRotation)();
+    // Single Animated value driving the bounce, 0 → 1 → 0.  Native
+    // driver (transform-only), so the loop runs off the JS thread.
+    const bounce = (0, react_1.useRef)(new react_native_1.Animated.Value(0)).current;
+    const direction = directionForOrientation(orientation);
+    (0, react_1.useEffect)(() => {
+        if (!visible) {
+            bounce.setValue(0);
+            return;
+        }
+        const loop = react_native_1.Animated.loop(react_native_1.Animated.sequence([
+            react_native_1.Animated.timing(bounce, {
+                toValue: 1,
+                duration: BOUNCE_DURATION_MS,
+                easing: react_native_1.Easing.inOut(react_native_1.Easing.ease),
+                useNativeDriver: true,
+            }),
+            react_native_1.Animated.timing(bounce, {
+                toValue: 0,
+                duration: BOUNCE_DURATION_MS,
+                easing: react_native_1.Easing.inOut(react_native_1.Easing.ease),
+                useNativeDriver: true,
+            }),
+        ]));
+        loop.start();
+        return () => loop.stop();
+    }, [visible, bounce]);
+    // Translate 0→BOUNCE_DISTANCE along the pan axis.  In the upright
+    // (counter-rotated) frame, "down" moves +Y and "right" moves +X.
+    const travel = bounce.interpolate({
+        inputRange: [0, 1],
+        outputRange: [0, BOUNCE_DISTANCE],
+    });
+    const arrowTransform = (0, react_1.useMemo)(() => direction === 'down'
+        ? [{ translateY: travel }]
+        : [{ translateX: travel }], [direction, travel]);
+    if (!visible)
+        return null;
+    return (react_1.default.createElement(react_native_1.View
+    // box-none on the root: never intercept taps anywhere on the
+    // full-screen layer.  The inner content is also non-interactive.
+    , { 
+        // box-none on the root: never intercept taps anywhere on the
+        // full-screen layer.  The inner content is also non-interactive.
+        pointerEvents: "none", style: [styles.root, style] },
+        react_1.default.createElement(react_native_1.View, { style: [styles.content, contentRotation] },
+            react_1.default.createElement(guidanceGraphics_1.PanPhoneGraphic, { direction: direction, playing: visible }),
+            react_1.default.createElement(react_native_1.Animated.View, { style: [
+                    styles.arrow,
+                    direction === 'down' ? styles.arrowDown : styles.arrowRight,
+                    { transform: arrowTransform },
+                ] }))));
+}
+const styles = react_native_1.StyleSheet.create({
+    root: {
+        ...react_native_1.StyleSheet.absoluteFillObject,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    content: {
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    // CSS-triangle base: a zero-size box whose borders are coloured on
+    // one edge and transparent on the two adjacent edges, producing a
+    // filled triangle pointing away from the coloured edge.  The
+    // direction-specific styles below set which edge is amber.
+    arrow: {
+        width: 0,
+        height: 0,
+        backgroundColor: 'transparent',
+        borderStyle: 'solid',
+        marginTop: 8,
+    },
+    // Triangle pointing DOWN (Mode A): left + right borders transparent,
+    // TOP border amber → apex at the bottom.
+    arrowDown: {
+        borderLeftWidth: ARROW_SIZE / 2,
+        borderRightWidth: ARROW_SIZE / 2,
+        borderTopWidth: ARROW_SIZE,
+        borderLeftColor: 'transparent',
+        borderRightColor: 'transparent',
+        borderTopColor: guidanceTokens_1.GUIDANCE_TOKENS.amber,
+    },
+    // Triangle pointing RIGHT (Mode B): top + bottom borders
+    // transparent, LEFT border amber → apex on the right.
+    arrowRight: {
+        borderTopWidth: ARROW_SIZE / 2,
+        borderBottomWidth: ARROW_SIZE / 2,
+        borderLeftWidth: ARROW_SIZE,
+        borderTopColor: 'transparent',
+        borderBottomColor: 'transparent',
+        borderLeftColor: guidanceTokens_1.GUIDANCE_TOKENS.amber,
+    },
+});
+//# sourceMappingURL=PanHowToOverlay.js.map

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.d.ts

@@ -168,11 +168,11 @@ export interface FrameSelectionSettings {
     maxKeyframes: number;
     /**
      * Required NEW-content fraction (0..1) for a candidate frame to
-     * be accepted.  Default 0.20 = 20% novel content per accept.
-     * Lower = more frames accepted, larger panoramas.  Higher = fewer
-     * frames, faster captures but more conservative about coverage.
-     * Clamped to `[0.10, 0.80]` natively
-     * (`IncrementalStitcher.swift:962`).
+     * be accepted.  Default 0.15 = 15% novel content per accept (v0.16;
+     * was 0.20).  Lower = more frames accepted, denser overlap, more
+     * robust registration.  Higher = fewer frames, faster captures but
+     * more conservative about coverage.  Clamped to `[0.10, 0.80]`
+     * natively (`IncrementalStitcher.swift:962`) — 0.10 is the floor.
      */
     overlapThreshold: number;
     /**
@@ -182,7 +182,9 @@ export interface FrameSelectionSettings {
      * overlap threshold wasn't met — so a slow or static pan never goes
      * longer than this without a keyframe.  Counts toward `maxKeyframes`
      * (the cap still finalises the capture).  `0` disables it.  Default
-     * `2000` (2 s).  Maps to the native gate's `setMaxKeyframeIntervalMs`.
+     * `1500` (1.5 s) — with `maxKeyframes` 8 this bounds a static/slow
+     * capture to ~8×1.5 ≈ 12 s before the keyframe-count auto-finalize.
+     * Maps to the native gate's `setMaxKeyframeIntervalMs`.
      */
     maxKeyframeIntervalMs: number;
     /**

package/dist/camera/PanoramaSettings.js

@@ -77,7 +77,18 @@ exports.DEFAULT_PANORAMA_SETTINGS = {
     captureSource: 'ar',
     debug: false,
     stitcher: {
+        // 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',
@@ -89,9 +100,16 @@ exports.DEFAULT_PANORAMA_SETTINGS = {
     },
     frameSelection: {
         mode: 'flow-based',
+        // 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: 2000,
+        maxKeyframeIntervalMs: 1500,
         flow: exports.DEFAULT_FLOW_GATE_SETTINGS,
     },
 };

package/dist/camera/PanoramaSettingsModal.js

@@ -182,17 +182,17 @@ function PanoramaSettingsModal({ visible, settings, onChange, onClose, }) {
                         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." }),
+                            }), caption: "Hard cap on accepted keyframes; native clamps to [3, 10].  8 (default) is the sweet spot for cv::detail BA convergence while giving the 15%-overlap + 1 s time gate room to land frames." }),
                         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({
+                        react_1.default.createElement(SegmentedControl, { options: ['10%', '15%', '20%', '30%'], 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%]." }),
+                            }), caption: "Required NEW-content fraction (lower = denser keyframes, more overlap).  15% (default): ~7\u20139 keyframes for a 90\u00B0 pan.  10% is the native clamp floor." }),
                         react_1.default.createElement(SectionHeader, { title: "Keyframe interval (time-budget force-accept)" }),
                         react_1.default.createElement(SegmentedControl, { options: ['off', '1s', '2s', '3s', '5s'], value: settings.frameSelection.maxKeyframeIntervalMs === 0
                                 ? 'off'
                                 : `${settings.frameSelection.maxKeyframeIntervalMs / 1000}s`, onChange: (v) => updateFrameSelection({
                                 maxKeyframeIntervalMs: v === 'off' ? 0 : parseInt(v, 10) * 1000,
-                            }), caption: "Force-accept a keyframe at least this often even if novelty is low, so slow / static pans don't leave gaps.  Counts toward the keyframe cap.  off = disabled.  2s (default).  Applies to AR + non-AR." }),
+                            }), caption: "Force-accept a keyframe at least this often even if novelty is low, so slow / static pans don't leave gaps.  Counts toward the keyframe cap.  off = disabled.  1s (default).  Applies to AR + non-AR." }),
                         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)" }),

package/dist/camera/RectCropPreview.d.ts

@@ -0,0 +1,135 @@
+/**
+ * RectCropPreview — item-7 of the first-time-user guidance flow: the
+ * post-capture crop editor.
+ *
+ * Shows the full stitched result image (contain-fit, letterboxed) with a
+ * 4-corner quad overlay.  Each corner is INDEPENDENTLY draggable in
+ * on-screen coords via RN-core `PanResponder` (deliberately NO
+ * react-native-gesture-handler dependency — this library ships zero extra
+ * native deps for guidance).  Corner positions are mapped to image-pixel
+ * space through the pure `cropGeometry` letterbox transform.
+ *
+ * ## What it surfaces (and what it does NOT do)
+ *
+ * This component is presentation + gesture only.  On confirm it computes
+ * the 4 image-pixel corners and hands them to `onConfirm` — it does NOT
+ * call any native crop.  The PARENT decides between the cheap axis-aligned
+ * `cropToRect` (when the quad is ~rectangular) and the perspective
+ * `cropToQuad`, using the `perspective` flag in the result:
+ *
+ *   onConfirm({ quad, perspective: perspectiveCorrect && !isAxisAligned })
+ *
+ * Promoted + extended from `example/InscribedRectDebug.tsx`, which already
+ * did the image-px ↔ on-screen contain-fit mapping, a rect overlay, and
+ * the in-place native crop.  This version replaces the single computed
+ * inscribed rect with a user-draggable free quad and the perspective
+ * decision; the letterbox math now lives in the shared `cropGeometry`
+ * module.  Styling is carried over from InscribedRectDebug.
+ *
+ * ## Seeding
+ *
+ * The initial quad comes from `initialRect` (image-pixel coords) when the
+ * host passes one — `<Camera>` passes the panorama's MAX-INSCRIBED rectangle
+ * (the tightest clean rectangle with no black corners; item 2) so the editor
+ * opens on a sensible crop the user drags to taste.  With no `initialRect`
+ * (native inscribed-rect unavailable) it falls back to an 8 %-inset
+ * rectangle.  "Reset" returns to whichever seed was used.
+ */
+import React from 'react';
+import { type GuidanceCopy } from './cameraGuidanceCopy';
+import { type Quad } from './cropGeometry';
+/** Image-pixel rectangle, used for the optional `initialRect` seed. */
+export interface ImageRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** What the host receives when the user taps Crop. */
+export interface RectCropResult {
+    /**
+     * The 4 chosen corners in IMAGE-PIXEL space, canonically ordered
+     * [TL, TR, BR, BL].  The host feeds these to the native crop.
+     */
+    quad: Quad;
+    /**
+     * `true` → the host should perspective-rectify (`cropToQuad`): the user
+     * picked a non-rectangular quad and `perspectiveCorrect` is enabled.
+     * `false` → the host can use the cheap axis-aligned `cropToRect` (the
+     * quad is ~rectangular, or perspective correction is disabled).
+     */
+    perspective: boolean;
+}
+export interface RectCropPreviewProps {
+    /** file:// URI of the full result image to crop. */
+    imageUri: string;
+    /** Intrinsic pixel width of `imageUri`. */
+    imageWidth: number;
+    /** Intrinsic pixel height of `imageUri`. */
+    imageHeight: number;
+    /** Show / hide the editor. */
+    visible: boolean;
+    /**
+     * Tapped on "Crop".  Receives the ordered image-pixel quad + the
+     * perspective decision; the host performs the actual native crop.
+     */
+    onConfirm: (result: RectCropResult) => void;
+    /**
+     * Tapped on "Use original" (or hardware back / dismiss) — emit the stitch
+     * un-cropped.  Also called when the user collapses the quad to something
+     * un-warpable, so a degenerate quad never reaches the native crop.
+     */
+    onUseOriginal: (uri?: string) => void;
+    /**
+     * Tapped on "Retake" — discard this capture entirely and return to the
+     * camera.  No result is emitted (the host clears the editor + lets the
+     * user capture again).
+     */
+    onRetake: () => void;
+    /**
+     * Optional non-fatal warning messages (e.g. "<70 % of frames used") shown
+     * as a banner across the top of the editor so the user sees them before
+     * accepting a crop.  Empty / undefined → no banner.
+     */
+    warnings?: string[];
+    /**
+     * Crop mode vs preview-only mode.  `true` (default) shows the draggable
+     * quad + corner handles + the [Retake][Use original][Crop] bar — the full
+     * crop editor.  `false` hides the quad and all crop affordances, showing
+     * just the stitched image with a [Retake][Confirm] bar — a plain preview
+     * (`<Camera showPreview>` without `rectCrop`).  Confirm emits the image
+     * un-cropped (same as "Use original").
+     */
+    showCropControls?: boolean;
+    /**
+     * Optional image-pixel seed rect for the draggable quad.  Defaults to
+     * an 8 %-inset rectangle of the full image.  Ignored in preview-only mode.
+     */
+    initialRect?: ImageRect;
+    /** Copy overrides (cropConfirm / cropReset). Falls back to defaults. */
+    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 (warnings)
+     * clear of the notch/Dynamic Island and the bottom button bar clear of the
+     * home indicator.  Default 0.
+     */
+    topInset?: number;
+    bottomInset?: number;
+    /**
+     * 2026-06-14 (DEV overlay) — optional multi-line debug text describing how
+     * this output was stitched (pipeline / warper / route / seam / blend / score
+     * / frames / size).  When non-empty, rendered as a small monospace pill in
+     * the top-right corner.  The host gates this on `__DEV__`; this component
+     * just renders whatever non-empty string it's given.
+     */
+    debugInfo?: string;
+    /**
+     * 2026-06-15 — show the live memory-footprint pill (polled native RSS,
+     * green/amber/red) on the preview too, so the operator can watch the spike
+     * when the on-demand high-level re-stitch fires.  Host gates on settings.debug.
+     */
+    showMemoryPill?: boolean;
+}
+export declare function RectCropPreview(props: RectCropPreviewProps): React.JSX.Element;
+//# sourceMappingURL=RectCropPreview.d.ts.map