@mikashboks/capture-intelligence-core 0.2.3 → 0.2.5

package/dist/esm/document-crop-arbitration.js

@@ -0,0 +1,642 @@
+import { decideCaptureTrust } from './capture-trust.js';
+export const DEFAULT_CROP_CONFIDENCE_THRESHOLD = 0.8;
+export const DEFAULT_RECTANGLE_CROP_CONFIDENCE_THRESHOLD = 0.88;
+export const DEFAULT_SUBMIT_CROP_INSET_FLOOR_ENABLED = true;
+export const DOCUMENT_CROP_ASPECT_MIN = 0.45;
+export const DOCUMENT_CROP_ASPECT_MAX = 2.15;
+export const CARD_LIKE_MEASURED_CROP_MIN_AREA_RATIO = 0.06;
+export const QUIET_ZONE_CLAMP_CUT_OFF_RISK_LOSS = 0.8;
+export const SAFE_LIVE_QUAD_INSET_MIN = 0.02;
+const DOCUMENT_CROP_VISIBLE_EDGE_INSET_RATIO = 0.02;
+const REVIEW_AUTO_CROP_VISIBLE_EDGE_INSET_RATIO = 0.05;
+const DEFAULT_SUBMIT_CROP_VISIBLE_EDGE_INSET_RATIO = 0.055;
+const TRUSTED_LIVE_BOUNDS_MIN_AREA_RATIO = 0.035;
+const DEFAULT_CROP_OUTPUT_MIN_LONG_SIDE = 900;
+const DEFAULT_CROP_OUTPUT_MIN_SHORT_SIDE = 500;
+const TRUSTED_LIVE_BOUNDS_CROP_OUTPUT_MIN_LONG_SIDE = 520;
+const TRUSTED_LIVE_BOUNDS_CROP_OUTPUT_MIN_SHORT_SIDE = 300;
+const CAPTURE_CANDIDATE_HIGH_CLASSIFIER_CONFIDENCE = 70;
+const CAPTURE_CANDIDATE_MRZ_CONFIRMED_CONFIDENCE_MIN = 0.45;
+const NATIVE_OVERFULL_AREA_RATIO_MIN = 0.92;
+const EXPLICIT_DOCUMENT_CUT_OFF_REASONS = new Set([
+    'cut_off',
+    'cutoff',
+    'document_cut_off',
+    'document_cutoff',
+    'edge_cut_off',
+    'missing_edge',
+    'missing_edges',
+    'partially_cropped',
+    'border_touching',
+    'border_touched',
+    'touching_border',
+]);
+const EXPLICIT_UNSAFE_CAPTURE_REASONS = new Set([
+    ...EXPLICIT_DOCUMENT_CUT_OFF_REASONS,
+    'unsafe_crop',
+    'unsafe_crop_rejected',
+    'crop_too_narrow',
+    'too_narrow',
+]);
+const DOCUMENT_CROP_SAFETY_THRESHOLDS_BY_FAMILY = {
+    'card-like': {
+        minAreaRatio: 0.2,
+        minWidthRatio: 0.18,
+        minHeightRatio: 0.12,
+        maxHorizontalOutsideMarginRatio: 0.62,
+        maxVerticalOutsideMarginRatio: 0.62,
+        aspectMin: 1.1,
+        aspectMax: DOCUMENT_CROP_ASPECT_MAX,
+    },
+    'passport-like': {
+        minAreaRatio: 0.1,
+        minWidthRatio: 0.18,
+        minHeightRatio: 0.18,
+        maxHorizontalOutsideMarginRatio: 0.55,
+        maxVerticalOutsideMarginRatio: 0.55,
+        aspectMin: 1.05,
+        aspectMax: 1.85,
+        useNormalizedAspect: true,
+    },
+    'document-page-like': {
+        minAreaRatio: 0.14,
+        minWidthRatio: 0.22,
+        minHeightRatio: 0.18,
+        maxHorizontalOutsideMarginRatio: 0.48,
+        maxVerticalOutsideMarginRatio: 0.48,
+        aspectMin: 0.6,
+        aspectMax: 1.65,
+        useNormalizedAspect: true,
+    },
+};
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const normalizeReason = (reason) => (reason ?? '').trim().toLowerCase();
+export const isCardLikeCropAspect = (aspectRatio) => Number.isFinite(aspectRatio) && aspectRatio >= 1.1 && aspectRatio <= DOCUMENT_CROP_ASPECT_MAX;
+export const getDocumentCropShapeFamily = (aspectRatio) => {
+    if (isCardLikeCropAspect(aspectRatio))
+        return 'card-like';
+    if (Number.isFinite(aspectRatio) && aspectRatio >= 0.6 && aspectRatio <= 1.85) {
+        return 'passport-like';
+    }
+    return 'document-page-like';
+};
+export const getDocumentCropSafetyThresholds = (aspectRatio, shapeFamily) => {
+    return DOCUMENT_CROP_SAFETY_THRESHOLDS_BY_FAMILY[shapeFamily ?? getDocumentCropShapeFamily(aspectRatio)];
+};
+export const getDocumentCropSafetyAspectRatio = (aspectRatio, safetyThresholds) => safetyThresholds.useNormalizedAspect && Number.isFinite(aspectRatio) && aspectRatio > 0
+    ? Math.max(aspectRatio, 1 / aspectRatio)
+    : aspectRatio;
+export const isDocumentCropAspectSafe = (aspectRatio, safetyThresholds) => {
+    const effectiveAspectRatio = getDocumentCropSafetyAspectRatio(aspectRatio, safetyThresholds);
+    return (Number.isFinite(effectiveAspectRatio) &&
+        effectiveAspectRatio >= safetyThresholds.aspectMin &&
+        effectiveAspectRatio <= safetyThresholds.aspectMax);
+};
+export const getMeasuredDocumentCropMinAreaRatio = (aspectRatio, shapeFamily) => {
+    const resolvedShapeFamily = shapeFamily ?? getDocumentCropShapeFamily(aspectRatio);
+    const safetyThresholds = getDocumentCropSafetyThresholds(aspectRatio, resolvedShapeFamily);
+    if (resolvedShapeFamily === 'card-like' &&
+        isDocumentCropAspectSafe(aspectRatio, safetyThresholds)) {
+        return Math.min(safetyThresholds.minAreaRatio, CARD_LIKE_MEASURED_CROP_MIN_AREA_RATIO);
+    }
+    return safetyThresholds.minAreaRatio;
+};
+export const hasExplicitDocumentCutOffReason = (reason) => EXPLICIT_DOCUMENT_CUT_OFF_REASONS.has(normalizeReason(reason));
+export const hasExplicitUnsafeCaptureReason = (reason) => EXPLICIT_UNSAFE_CAPTURE_REASONS.has(normalizeReason(reason));
+export const hasCaptureDocumentCutOffEvidence = (metadata) => {
+    if (!metadata)
+        return false;
+    return (hasExplicitDocumentCutOffReason(metadata.reason) ||
+        hasExplicitUnsafeCaptureReason(metadata.reason));
+};
+const isContourBackedDocumentBoundsDetector = (detector) => detector === 'scanic' || detector === 'kt-jscanify';
+const isNativeViewfinderCrop = (metadata) => Boolean(metadata &&
+    (metadata.cropSource === 'viewfinder_candidate' ||
+        metadata.scannerEngine === 'native-viewfinder' ||
+        metadata.reason === 'web_native_viewfinder_capture'));
+const isMeasuredCardViewfinderCrop = (metadata) => metadata.scannerEngine === 'native-viewfinder' &&
+    metadata.cropSource === 'viewfinder_candidate' &&
+    metadata.cropShapeFamily === 'card-like';
+const isTrustedLiveBoundsCrop = (metadata) => metadata.cropSource === 'live_quad_candidate' &&
+    metadata.cropVerified === true &&
+    metadata.cornersOk === true &&
+    metadata.liveBoundsReliable !== false &&
+    isFiniteNumber(metadata.liveQuadInsetMin) &&
+    metadata.liveQuadInsetMin >= SAFE_LIVE_QUAD_INSET_MIN &&
+    (metadata.cropShapeFamily === 'card-like' || metadata.cropShapeFamily === 'passport-like');
+const isMrzAnchoredPassportDataPageCrop = (metadata) => metadata.cropSource === 'mrz_anchor_candidate' &&
+    metadata.reason === 'detected_passport_data_page' &&
+    metadata.cornersOk === true &&
+    metadata.cropShapeFamily === 'passport-like';
+const hasUnsafeLiveQuadCropEvidence = (metadata) => Boolean(metadata.cropSource === 'live_quad_candidate' &&
+    metadata.liveQuadPresent !== false &&
+    isFiniteNumber(metadata.liveQuadInsetMin) &&
+    metadata.liveQuadInsetMin < SAFE_LIVE_QUAD_INSET_MIN);
+const isReviewAutoCrop = (metadata) => metadata.cropProvenance === 'review_auto_crop' || metadata.cropSource === 'review_auto_crop';
+const getDefaultableVisibleEdgeInsetRatio = (metadata) => isReviewAutoCrop(metadata)
+    ? REVIEW_AUTO_CROP_VISIBLE_EDGE_INSET_RATIO
+    : DOCUMENT_CROP_VISIBLE_EDGE_INSET_RATIO;
+const hasQuietZoneClampCutOffEvidence = (metadata) => Boolean(metadata &&
+    isFiniteNumber(metadata.quietZoneClampLossFraction) &&
+    metadata.quietZoneClampLossFraction >= QUIET_ZONE_CLAMP_CUT_OFF_RISK_LOSS);
+const getCropAreaRatio = (rect, sourceImageSize) => (rect.w * rect.h) / Math.max(1, sourceImageSize.width * sourceImageSize.height);
+const getCropAspectRatio = (rect) => (rect.h > 0 ? rect.w / rect.h : 0);
+const getCropMinAreaRatio = (metadata, aspectRatio, shapeFamily) => {
+    if (isTrustedLiveBoundsCrop(metadata)) {
+        return Math.min(getDocumentCropSafetyThresholds(aspectRatio, shapeFamily).minAreaRatio, TRUSTED_LIVE_BOUNDS_MIN_AREA_RATIO);
+    }
+    if (isMeasuredCardViewfinderCrop(metadata)) {
+        return getMeasuredDocumentCropMinAreaRatio(aspectRatio, shapeFamily);
+    }
+    return getDocumentCropSafetyThresholds(aspectRatio, shapeFamily).minAreaRatio;
+};
+const hasDocumentCropGeometry = (metadata) => Boolean(metadata.rect && metadata.sourceImageSize);
+const getCropSafetyInputs = (metadata) => {
+    const { rect, sourceImageSize } = metadata;
+    if (!rect || !sourceImageSize)
+        return null;
+    if (!isFiniteNumber(sourceImageSize.width) ||
+        !isFiniteNumber(sourceImageSize.height) ||
+        sourceImageSize.width <= 0 ||
+        sourceImageSize.height <= 0 ||
+        !isFiniteNumber(rect.x) ||
+        !isFiniteNumber(rect.y) ||
+        !isFiniteNumber(rect.w) ||
+        !isFiniteNumber(rect.h) ||
+        rect.w <= 0 ||
+        rect.h <= 0) {
+        return null;
+    }
+    const width = Math.max(1, sourceImageSize.width);
+    const height = Math.max(1, sourceImageSize.height);
+    const widthRatio = rect.w / width;
+    const heightRatio = rect.h / height;
+    const leftMarginRatio = rect.x / width;
+    const topMarginRatio = rect.y / height;
+    const rightMarginRatio = (sourceImageSize.width - (rect.x + rect.w)) / width;
+    const bottomMarginRatio = (sourceImageSize.height - (rect.y + rect.h)) / height;
+    const areaRatio = isFiniteNumber(metadata.areaRatio)
+        ? metadata.areaRatio
+        : getCropAreaRatio(rect, sourceImageSize);
+    const aspectRatio = isFiniteNumber(metadata.aspectRatio)
+        ? metadata.aspectRatio
+        : getCropAspectRatio(rect);
+    return {
+        rect,
+        sourceImageSize,
+        widthRatio,
+        heightRatio,
+        leftMarginRatio,
+        topMarginRatio,
+        rightMarginRatio,
+        bottomMarginRatio,
+        areaRatio,
+        aspectRatio,
+        shapeFamily: metadata.cropShapeFamily,
+    };
+};
+const isDocumentCropGeometrySafe = (metadata) => {
+    if (metadata.clamped || metadata.unsafeReason)
+        return false;
+    const safetyInputs = getCropSafetyInputs(metadata);
+    if (!safetyInputs)
+        return false;
+    const { widthRatio, heightRatio, leftMarginRatio, topMarginRatio, rightMarginRatio, bottomMarginRatio, areaRatio, aspectRatio, shapeFamily, } = safetyInputs;
+    const safetyThresholds = getDocumentCropSafetyThresholds(aspectRatio, shapeFamily);
+    const minAreaRatio = getCropMinAreaRatio(metadata, aspectRatio, shapeFamily);
+    if (!isFiniteNumber(areaRatio) || !isFiniteNumber(aspectRatio))
+        return false;
+    if (areaRatio < minAreaRatio)
+        return false;
+    if (widthRatio < safetyThresholds.minWidthRatio ||
+        heightRatio < safetyThresholds.minHeightRatio) {
+        return false;
+    }
+    if (!isDocumentCropAspectSafe(aspectRatio, safetyThresholds))
+        return false;
+    if (leftMarginRatio < 0 ||
+        rightMarginRatio < 0 ||
+        topMarginRatio < 0 ||
+        bottomMarginRatio < 0 ||
+        leftMarginRatio > safetyThresholds.maxHorizontalOutsideMarginRatio ||
+        rightMarginRatio > safetyThresholds.maxHorizontalOutsideMarginRatio ||
+        topMarginRatio > safetyThresholds.maxVerticalOutsideMarginRatio ||
+        bottomMarginRatio > safetyThresholds.maxVerticalOutsideMarginRatio) {
+        return false;
+    }
+    return true;
+};
+const getPointInsetRatio = (point, sourceImageSize) => Math.min(point.x / Math.max(1, sourceImageSize.width), point.y / Math.max(1, sourceImageSize.height), (sourceImageSize.width - point.x) / Math.max(1, sourceImageSize.width), (sourceImageSize.height - point.y) / Math.max(1, sourceImageSize.height));
+const getMinimumPolygonInsetRatio = (metadata) => {
+    const { polygon, sourceImageSize } = metadata;
+    if (!polygon || !sourceImageSize)
+        return null;
+    const points = [polygon.topLeft, polygon.topRight, polygon.bottomRight, polygon.bottomLeft];
+    if (points.some(point => !isFiniteNumber(point.x) || !isFiniteNumber(point.y)) ||
+        !isFiniteNumber(sourceImageSize.width) ||
+        !isFiniteNumber(sourceImageSize.height) ||
+        sourceImageSize.width <= 0 ||
+        sourceImageSize.height <= 0) {
+        return null;
+    }
+    return Math.min(...points.map(point => getPointInsetRatio(point, sourceImageSize)));
+};
+const getMinimumCropInsetRatio = (metadata) => {
+    const polygonInsetRatio = getMinimumPolygonInsetRatio(metadata);
+    if (polygonInsetRatio !== null)
+        return polygonInsetRatio;
+    if (!isReviewAutoCrop(metadata))
+        return null;
+    const safetyInputs = getCropSafetyInputs(metadata);
+    if (!safetyInputs)
+        return null;
+    return Math.min(safetyInputs.leftMarginRatio, safetyInputs.topMarginRatio, safetyInputs.rightMarginRatio, safetyInputs.bottomMarginRatio);
+};
+const getMinimumCropBoundsInsetRatio = (metadata) => {
+    const polygonInsetRatio = getMinimumPolygonInsetRatio(metadata);
+    if (polygonInsetRatio !== null)
+        return polygonInsetRatio;
+    const safetyInputs = getCropSafetyInputs(metadata);
+    if (!safetyInputs)
+        return null;
+    return Math.min(safetyInputs.leftMarginRatio, safetyInputs.topMarginRatio, safetyInputs.rightMarginRatio, safetyInputs.bottomMarginRatio);
+};
+export const hasMarginSafeDocumentCropEvidence = (metadata) => {
+    const minimumInsetRatio = getMinimumCropInsetRatio(metadata);
+    const minimumRequiredInsetRatio = getDefaultableVisibleEdgeInsetRatio(metadata);
+    return Boolean((metadata.confidence ?? 0) >= 0.6 &&
+        minimumInsetRatio !== null &&
+        minimumInsetRatio >= minimumRequiredInsetRatio &&
+        isDocumentCropGeometrySafe(metadata));
+};
+const hasMarginSafeReliableCaptureQuad = (metadata) => Boolean(metadata?.liveQuadPresent &&
+    isContourBackedDocumentBoundsDetector(metadata.liveBoundsDetector) &&
+    metadata.liveBoundsReliable !== false &&
+    isFiniteNumber(metadata.liveQuadInsetMin) &&
+    metadata.liveQuadInsetMin >= SAFE_LIVE_QUAD_INSET_MIN);
+const hasUnsafeInsetReliableCaptureQuad = (metadata) => Boolean(metadata?.liveQuadPresent &&
+    isContourBackedDocumentBoundsDetector(metadata.liveBoundsDetector) &&
+    metadata.liveBoundsReliable !== false &&
+    isFiniteNumber(metadata.liveQuadInsetMin) &&
+    metadata.liveQuadInsetMin < SAFE_LIVE_QUAD_INSET_MIN);
+const normalizeEvidenceKey = (value) => String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, '_');
+const isBackSideStrategy = (strategy) => normalizeEvidenceKey(strategy).endsWith('_back');
+const isCardFrontCaptureContext = (metadata) => {
+    if (metadata?.cropShapeFamily !== 'card-like')
+        return false;
+    if (isBackSideStrategy(metadata?.liveRecognitionStrategy))
+        return false;
+    if (metadata?.liveRecognitionStrategy)
+        return true;
+    return !metadata?.liveRecognitionStrategy;
+};
+const getCapturePageRecognitionText = (metadata) => `${metadata?.liveRecognitionReason ?? ''} ${metadata?.liveRecognitionPath ?? ''}`
+    .trim()
+    .toLowerCase();
+const hasTrustedMrzCaptureEvidence = (metadata) => {
+    if (!metadata)
+        return false;
+    if (metadata.liveMrzCheckDigitsValid === false || metadata.liveMrzValidated === false) {
+        return false;
+    }
+    if (metadata.liveBoundsReliable === false && metadata.liveMrzValidated !== true)
+        return false;
+    if ((metadata.liveMrzConfidence ?? 0) < CAPTURE_CANDIDATE_MRZ_CONFIRMED_CONFIDENCE_MIN) {
+        return false;
+    }
+    if (metadata.liveMrzValidated === true)
+        return true;
+    if (metadata.liveMrzCheckDigitsValid === true)
+        return false;
+    const text = getCapturePageRecognitionText(metadata);
+    return metadata.liveRecognitionAccepted === true && text.includes('mrz');
+};
+const hasTrustedCardFrontRecognitionReason = (metadata) => {
+    if (!isCardFrontCaptureContext(metadata))
+        return true;
+    const reason = normalizeEvidenceKey(metadata?.liveRecognitionReason);
+    if (reason === 'quad' || reason === 'classifier')
+        return true;
+    if (isFiniteNumber(metadata?.classifierConfidence) &&
+        metadata.classifierConfidence >= CAPTURE_CANDIDATE_HIGH_CLASSIFIER_CONFIDENCE) {
+        return true;
+    }
+    return hasTrustedMrzCaptureEvidence(metadata);
+};
+const hasReadyCaptureCandidateDecision = (metadata) => metadata?.captureCandidateDecision === 'review_candidate' ||
+    metadata?.captureCandidateDecision === 'manual_ready' ||
+    metadata?.captureCandidateDecision === 'auto_ready';
+const hasReadySafeCardLiveEvidence = (metadata) => {
+    if (!metadata)
+        return false;
+    if (metadata.cropShapeFamily !== 'card-like')
+        return false;
+    const hasReadyCandidateDecision = hasReadyCaptureCandidateDecision(metadata);
+    const hasAcceptedLiveRecognition = metadata.liveRecognitionAccepted === true;
+    if (!hasReadyCandidateDecision && !hasAcceptedLiveRecognition)
+        return false;
+    if (!hasTrustedCardFrontRecognitionReason(metadata))
+        return false;
+    return hasMarginSafeReliableCaptureQuad(metadata);
+};
+const hasHardCaptureCutOffEvidence = (metadata) => Boolean(metadata?.clamped === true ||
+    metadata?.unsafeReason === 'clamped_edge' ||
+    hasUnsafeInsetReliableCaptureQuad(metadata));
+const isNativeViewfinderCaptureReason = (reason) => {
+    const normalized = String(reason || '').toLowerCase();
+    return (normalized === 'web_native_viewfinder_capture' ||
+        normalized.startsWith('web_native_viewfinder_capture_'));
+};
+const isNativeOverfullReason = (reason) => {
+    const normalized = String(reason || '').toLowerCase();
+    return (isNativeViewfinderCaptureReason(normalized) &&
+        (normalized.includes('too_large') ||
+            normalized.includes('nearly_full_frame') ||
+            normalized.includes('overfull') ||
+            normalized.includes('full_frame')));
+};
+const hasHighAreaNativeViewfinderEvidence = (metadata) => Boolean(isNativeViewfinderCaptureReason(metadata?.reason) &&
+    isFiniteNumber(metadata?.areaRatio) &&
+    metadata.areaRatio >= NATIVE_OVERFULL_AREA_RATIO_MIN);
+const hasNativeOverfullCaptureRisk = (metadata) => Boolean(isNativeViewfinderCaptureReason(metadata?.reason) &&
+    (metadata?.unsafeReason === 'too_large' ||
+        metadata?.unsafeReason === 'nearly_full_frame' ||
+        isNativeOverfullReason(metadata?.reason) ||
+        hasHighAreaNativeViewfinderEvidence(metadata)));
+const hasNativeClampedCaptureRisk = (metadata) => Boolean(isNativeViewfinderCaptureReason(metadata?.reason) &&
+    (metadata?.clamped === true || metadata?.unsafeReason === 'clamped_edge'));
+const canTrustReadySafeCardEvidenceOverNativeUnsafeRisk = (metadata) => (hasReadySafeCardLiveEvidence(metadata) &&
+    !hasHardCaptureCutOffEvidence(metadata) &&
+    hasNativeOverfullCaptureRisk(metadata)) ||
+    (hasReadySafeCardLiveEvidence(metadata) &&
+        hasNativeClampedCaptureRisk(metadata) &&
+        !hasUnsafeInsetReliableCaptureQuad(metadata));
+const hasReadySafeCardCropEvidence = (metadata) => !hasCaptureDocumentCutOffEvidence(metadata) &&
+    !hasHardCaptureCutOffEvidence(metadata) &&
+    isDocumentCropGeometrySafe(metadata) &&
+    hasReadySafeCardLiveEvidence(metadata) &&
+    (metadata.cutOffRisk !== 'high' || canTrustReadySafeCardEvidenceOverNativeUnsafeRisk(metadata));
+export const isDocumentCropVerified = (metadata) => metadata.applied === true &&
+    ((metadata.cropVerified === true &&
+        !isMeasuredCardViewfinderCrop(metadata) &&
+        !isReviewAutoCrop(metadata)) ||
+        (metadata.cornersOk === true && !isReviewAutoCrop(metadata)) ||
+        hasReadySafeCardCropEvidence(metadata) ||
+        (metadata.cornersOk !== false && hasMarginSafeDocumentCropEvidence(metadata)));
+const isSafeMeasuredNativeCrop = (metadata) => isNativeViewfinderCrop(metadata) &&
+    isDocumentCropVerified(metadata) &&
+    isDocumentCropGeometrySafe(metadata);
+export const getDocumentCropRejectedReason = (metadata) => {
+    if (hasQuietZoneClampCutOffEvidence(metadata))
+        return 'quiet_zone_clamped';
+    if (metadata.unsafeReason)
+        return metadata.unsafeReason;
+    if (metadata.clamped)
+        return 'clamped_edge';
+    const safetyInputs = getCropSafetyInputs(metadata);
+    if (!safetyInputs)
+        return 'unsafe_crop_rejected';
+    const { widthRatio, heightRatio, leftMarginRatio, topMarginRatio, rightMarginRatio, bottomMarginRatio, areaRatio, aspectRatio, shapeFamily, } = safetyInputs;
+    const safetyThresholds = getDocumentCropSafetyThresholds(aspectRatio, shapeFamily);
+    const minAreaRatio = getCropMinAreaRatio(metadata, aspectRatio, shapeFamily);
+    if (!isFiniteNumber(aspectRatio) ||
+        widthRatio < safetyThresholds.minWidthRatio ||
+        heightRatio < safetyThresholds.minHeightRatio ||
+        !isDocumentCropAspectSafe(aspectRatio, safetyThresholds)) {
+        return 'crop_too_narrow';
+    }
+    if (leftMarginRatio < 0 ||
+        rightMarginRatio < 0 ||
+        topMarginRatio < 0 ||
+        bottomMarginRatio < 0 ||
+        leftMarginRatio > safetyThresholds.maxHorizontalOutsideMarginRatio ||
+        rightMarginRatio > safetyThresholds.maxHorizontalOutsideMarginRatio ||
+        topMarginRatio > safetyThresholds.maxVerticalOutsideMarginRatio ||
+        bottomMarginRatio > safetyThresholds.maxVerticalOutsideMarginRatio) {
+        return 'unsafe_crop_rejected';
+    }
+    if (areaRatio < minAreaRatio)
+        return 'crop_too_small';
+    return 'unsafe_crop_rejected';
+};
+const getCropDefaultConfidenceThreshold = (cropMetadata) => cropMetadata.method === 'perspective'
+    ? DEFAULT_CROP_CONFIDENCE_THRESHOLD
+    : DEFAULT_RECTANGLE_CROP_CONFIDENCE_THRESHOLD;
+const buildCropArbitrationAssessment = ({ decision, policy, score, reason, reviewSafe, defaultSafe = false, cropVerified = false, cropSelectable = false, }) => ({
+    decision,
+    policy,
+    score,
+    reason,
+    reviewSafe,
+    defaultSafe,
+    cropVerified,
+    cropSelectable,
+});
+const hasDefaultableCropOutputDetail = (cropMetadata) => {
+    const size = cropMetadata.outputImageSize;
+    if (!size)
+        return true;
+    const trustedAnchoredCrop = isTrustedLiveBoundsCrop(cropMetadata) || isMrzAnchoredPassportDataPageCrop(cropMetadata);
+    const minLongSide = trustedAnchoredCrop
+        ? TRUSTED_LIVE_BOUNDS_CROP_OUTPUT_MIN_LONG_SIDE
+        : DEFAULT_CROP_OUTPUT_MIN_LONG_SIDE;
+    const minShortSide = trustedAnchoredCrop
+        ? TRUSTED_LIVE_BOUNDS_CROP_OUTPUT_MIN_SHORT_SIDE
+        : DEFAULT_CROP_OUTPUT_MIN_SHORT_SIDE;
+    return (Math.max(size.width, size.height) >= minLongSide &&
+        Math.min(size.width, size.height) >= minShortSide);
+};
+const hasDefaultSubmitInsetEvidence = (metadata) => {
+    const minimumInsetRatio = getMinimumCropBoundsInsetRatio(metadata);
+    return (minimumInsetRatio !== null && minimumInsetRatio >= DEFAULT_SUBMIT_CROP_VISIBLE_EDGE_INSET_RATIO);
+};
+export function assessDocumentCropCandidate(croppedBase64, cropMetadata) {
+    if (!cropMetadata || !croppedBase64 || !cropMetadata.applied) {
+        return buildCropArbitrationAssessment({
+            decision: 'unsafe_crop',
+            policy: 'disabled_unsafe',
+            score: 0,
+            reason: !cropMetadata ? 'missing_crop_metadata' : 'crop_not_applied',
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (hasCaptureDocumentCutOffEvidence(cropMetadata) ||
+        hasQuietZoneClampCutOffEvidence(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'unsafe_crop',
+            policy: 'disabled_unsafe',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 20)),
+            reason: hasQuietZoneClampCutOffEvidence(cropMetadata)
+                ? 'quiet_zone_clamped'
+                : cropMetadata.reason || 'explicit_cutoff_evidence',
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (hasUnsafeLiveQuadCropEvidence(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'unsafe_crop',
+            policy: 'disabled_unsafe',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 25)),
+            reason: 'edge_tight_live_quad',
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (cropMetadata.cropSelectable === false && !isNativeViewfinderCrop(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'unsafe_crop',
+            policy: 'disabled_unsafe',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 35)),
+            reason: 'crop_marked_unselectable',
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (!hasDocumentCropGeometry(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'original_only',
+            policy: 'original_only',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 45)),
+            reason: 'missing_crop_geometry',
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (!isDocumentCropGeometrySafe(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'unsafe_crop',
+            policy: 'disabled_unsafe',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 35)),
+            reason: getDocumentCropRejectedReason(cropMetadata),
+            reviewSafe: false,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    const hasTrustedCornerGeometry = isDocumentCropVerified(cropMetadata) || isSafeMeasuredNativeCrop(cropMetadata);
+    if (cropMetadata.cornersOk === false) {
+        return buildCropArbitrationAssessment({
+            decision: 'original_with_overlay',
+            policy: 'original_only',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 55)),
+            reason: 'corners_not_verified',
+            reviewSafe: true,
+            defaultSafe: false,
+            cropVerified: false,
+            cropSelectable: false,
+        });
+    }
+    if (!hasDefaultableCropOutputDetail(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'original_with_overlay',
+            policy: 'original_only',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 65)),
+            reason: 'crop_output_too_small',
+            reviewSafe: true,
+            defaultSafe: false,
+            cropVerified: hasTrustedCornerGeometry,
+            cropSelectable: false,
+        });
+    }
+    if (DEFAULT_SUBMIT_CROP_INSET_FLOOR_ENABLED &&
+        hasTrustedCornerGeometry &&
+        !hasDefaultSubmitInsetEvidence(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'original_with_overlay',
+            policy: 'original_only',
+            score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 65)),
+            reason: 'crop_inset_too_small',
+            reviewSafe: true,
+            defaultSafe: false,
+            cropVerified: hasTrustedCornerGeometry,
+            cropSelectable: false,
+        });
+    }
+    if (isSafeMeasuredNativeCrop(cropMetadata)) {
+        return buildCropArbitrationAssessment({
+            decision: 'default_crop',
+            policy: 'default',
+            score: Math.max(80, Math.round((cropMetadata.confidence ?? 0.55) * 100)),
+            reason: 'safe_measured_native_crop',
+            reviewSafe: true,
+            defaultSafe: true,
+            cropVerified: true,
+            cropSelectable: true,
+        });
+    }
+    if ((cropMetadata.confidence ?? 0) >= getCropDefaultConfidenceThreshold(cropMetadata) &&
+        hasTrustedCornerGeometry) {
+        return buildCropArbitrationAssessment({
+            decision: 'default_crop',
+            policy: 'default',
+            score: Math.max(80, Math.round((cropMetadata.confidence ?? 0) * 100)),
+            reason: 'safe_verified_crop',
+            reviewSafe: true,
+            defaultSafe: true,
+            cropVerified: true,
+            cropSelectable: true,
+        });
+    }
+    return buildCropArbitrationAssessment({
+        decision: 'original_with_overlay',
+        policy: 'original_only',
+        score: Math.max(0, Math.round((cropMetadata.confidence ?? 0) * 70)),
+        reason: hasTrustedCornerGeometry ? 'crop_confidence_too_low' : 'crop_not_verified',
+        reviewSafe: true,
+        defaultSafe: false,
+        cropVerified: hasTrustedCornerGeometry,
+        cropSelectable: false,
+    });
+}
+export function getDocumentCropReviewPolicy(croppedBase64, cropMetadata) {
+    return assessDocumentCropCandidate(croppedBase64, cropMetadata).policy;
+}
+export function getDocumentCropTrustTier(croppedBase64, cropMetadata, client = 'web') {
+    const assessment = assessDocumentCropCandidate(croppedBase64, cropMetadata);
+    return decideCaptureTrust({
+        context: {
+            client,
+            phase: 'capture',
+            captureSource: cropMetadata?.cropSource === 'native_platform_scanner'
+                ? 'native_platform_scanner'
+                : 'camera',
+        },
+        capture: {
+            hasMetrics: true,
+            documentCandidate: true,
+            reviewSafe: assessment.reviewSafe,
+            autoSafe: false,
+        },
+        crop: {
+            applied: cropMetadata?.applied,
+            provenance: cropMetadata?.cropProvenance ?? cropMetadata?.cropSource ?? null,
+            unsafe: assessment.decision === 'unsafe_crop' || assessment.policy === 'disabled_unsafe',
+            unsafeReason: cropMetadata?.unsafeReason ?? undefined,
+            clamped: cropMetadata?.clamped,
+            cutOffRisk: cropMetadata?.cutOffRisk,
+            aspectSafe: assessment.reason === 'crop_bad_aspect' ? false : undefined,
+            cornersOk: cropMetadata?.cornersOk,
+            cropVerified: assessment.cropVerified,
+            cropSelectable: assessment.cropSelectable,
+            footprintTrusted: assessment.defaultSafe,
+            renderedContentOk: assessment.defaultSafe || assessment.reviewSafe,
+        },
+    }).cropTrustTier;
+}
+//# sourceMappingURL=document-crop-arbitration.js.map