@incodetech/core 2.2.0-rc.6 → 2.2.0

package/dist/{idCaptureServices-28d5mDGM.esm.js → idCaptureServices-44kwQItl.esm.js}

@@ -1,11 +1,11 @@
-import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-Bo_xbwQa.esm.js";
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-CPQ4qv3F.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
 import { r as isDesktop } from "./platform-BJrm5nzZ.esm.js";
-import { h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-CTinxa9H.esm.js";
+import { h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
 import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-9y-kbVDw.esm.js";
-import { n as preloadOpenViduProvider } from "./recordingService-DtWTn91V.esm.js";
+import { n as preloadOpenViduProvider } from "./recordingService-3NSENVwp.esm.js";
 import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-WeHbQM7W.esm.js";
 //#region src/modules/id/idCameraStream.ts
 async function getIdCameraStream(deviceId) {
@@ -14,25 +14,149 @@ async function getIdCameraStream(deviceId) {
 //#endregion
 //#region src/modules/id/idCaptureExperiments.ts
 /**
+* IDC-05 splits the WASM frames-aggregation window into a silent live half
+* (`framesAggregationIntervalMs`, "Taking photo…") and an optimizing half
+* (`resultPreviewDwellMs`, "Successfully captured" / "Optimizing your capture…")
+* during which detection keeps running, so the frame that finally uploads is
+* the best across both halves. WASM receives their sum. iOS uses 1500 + 1500
+* (`IDCaptureExp05Timing`).
+*
+* The two param names below are the **Statsig payload keys**, deliberately kept
+* as originally configured; everything downstream of
+* `resolveCaptureOptimizingTreatment` speaks of the optimizing phase instead
+* (`captureWindowMs` / `optimizingDwellMs`). Renaming a key here renames what
+* the console must send, and a payload still using the old spelling would
+* silently fall back to these code defaults.
+*
+* The split is NOT pinned to a fixed total. The only ceiling is the session's
+* autocapture budget, applied in `resolveCaptureOptimizingTreatment`: a
+* payload whose halves exceed it is halved to fit rather than rejected, and a
+* session whose budget cannot fit a meaningful split runs the countdown arm.
+* Note this means the console payload decides total capture duration — a
+* treatment payload that leaves `framesAggregationIntervalMs` at its 3000
+* default produces a 4500ms window against the 5s default budget, i.e. longer
+* than the countdown arm's 3000ms. Set both halves explicitly.
+*/
+const MAX_OPTIMIZING_DWELL_MS = 2500;
+const DEFAULT_OPTIMIZING_DWELL_MS = 1500;
+/**
+* How long the machine waits for WASM's commit *after* the optimizing phase has
+* had its full dwell, before treating the window as abandoned
+* (`optimizingGrace`, `idCaptureStateMachine.ts`).
+*
+* The phase is expected to last exactly one dwell: it starts at
+* `T0 + captureWindowMs` and WASM closes its aggregation window with
+* `onCapture` at `T0 + captureWindowMs + optimizingDwellMs`. This grace covers
+* the case where that `onCapture` never arrives — aggregation aborting
+* mid-phase because the document left the frame, so the window the frozen still
+* belongs to is simply abandoned.
+*
+* Sized to be unreachable on a healthy phase: WASM's frame loop and the JS
+* boundary timer both jitter, and a late boundary only *delays* the phase, which
+* delays this grace with it — so the only way to overrun a full second past the
+* dwell is that no commit is coming.
+*/
+const OPTIMIZING_WATCHDOG_MARGIN_MS = 1e3;
+/**
 * IDC-05 — resolved by core because `framesAggregationIntervalMs` feeds
 * `setThresholds` before detection can run.
+*
+* `framesAggregationIntervalMs` carries no upper bound here because it means
+* two different things depending on the arm: the WHOLE aggregation window in
+* the countdown arm, only the pre-boundary half in the treatment arm. Bounding it
+* for one would break the other, so the arm-aware handling lives in
+* `resolveCaptureOptimizingTreatment`. Its code default stays at the
+* canonical 3000 so an unallocated session keeps shipped control behavior.
 */
-const CAPTURE_RESULT_PREVIEW = {
+const CAPTURE_OPTIMIZING = {
 	storeParam: "idcExp05ShowResult",
 	...defineExperimentParams({
 		showCaptureResultPreview: booleanParam(false),
-		framesAggregationIntervalMs: numberParam(DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval)
+		framesAggregationIntervalMs: numberParam(DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval, { min: 0 }),
+		resultPreviewDwellMs: numberParam(DEFAULT_OPTIMIZING_DWELL_MS, {
+			min: 0,
+			max: MAX_OPTIMIZING_DWELL_MS
+		})
 	})
 };
 //#endregion
 //#region src/modules/id/idCaptureThresholds.ts
-function resolveCaptureResultPreviewTreatment(config) {
-	if (config.supportsCaptureResultPreview !== true) return void 0;
-	const { params } = resolveExperimentOnce(CAPTURE_RESULT_PREVIEW);
-	return {
-		mode: params.showCaptureResultPreview ? "result-preview" : "countdown",
+/**
+* WASM restarts its manual-capture timer at first ID *detection* but only opens
+* the frames-aggregation window at the first *good-quality* frame, and never
+* stops that timer once aggregation begins. If it fires mid-window it captures
+* early (`CapturingManager.cpp`, the `isLookingForBestFrame` branch of the
+* `manualCaptureTimer` interval callback), which would truncate the
+* optimizing half.
+*/
+const AUTOCAPTURE_SAFETY_MARGIN_MS = 500;
+/**
+* Smallest autocapture budget that can still carry a meaningful IDC-05 split.
+*
+* An over-budget payload is halved to fit (below), so the budget alone decides
+* how short each half can get. At 3000ms each half is 1500ms — the iOS timing
+* and the shortest pre-boundary window that reliably yields a best frame. Below
+* that the session runs the countdown arm instead: a 1000ms/1000ms split would
+* reveal a frame WASM has barely had time to score.
+*
+* Budget is `autocaptureTimeout - AUTOCAPTURE_SAFETY_MARGIN_MS`, so this floor
+* means an effective `autocaptureTimeout` of at least 3500ms.
+*/
+const MIN_EXPERIMENT_AUTOCAPTURE_BUDGET_MS = 3e3;
+/**
+* The autocapture window WASM will be given, derived the same way whether the
+* caller is building thresholds or checking whether a split window fits inside
+* it. Shared so the two can't drift.
+*/
+function resolveAutocaptureTimeout(config) {
+	return config.thresholds?.autocaptureTimeout ?? (config.autoCaptureTimeout ?? 5) * 1e3;
+}
+/**
+* Resolves the IDC-05 arm and, for the treatment, the two halves of the capture
+* window. Precedence:
+*
+* 1. An explicit `config.thresholds.framesAggregationInterval` (host/headless
+*    override) opts the session OUT of the treatment: the host has deliberately
+*    pinned the capture window, and splitting it against that intent is worse
+*    than not running the experiment on that traffic.
+* 2. Countdown arm (or unallocated) → the experiment's interval straight
+*    through, unchanged from before this split existed.
+* 3. Treatment arm, budget too small for a viable split → countdown arm on the
+*    CANONICAL window (not the payload's, see below).
+* 4. Treatment arm → the payload's two halves, each halved to `budget / 2` if
+*    their sum would overrun the autocapture budget. Deliberately no contract
+*    on the total and no rejection path: an out-of-range payload is fitted, not
+*    refused, so no session logs a warning or silently runs mis-timed.
+*/
+function resolveCaptureOptimizingTreatment(config) {
+	if (config.supportsOptimizingStatus !== true) return void 0;
+	const { params } = resolveExperimentOnce(CAPTURE_OPTIMIZING);
+	const hostInterval = config.thresholds?.framesAggregationInterval;
+	if (hostInterval !== void 0) return {
+		mode: "countdown",
+		framesAggregationInterval: hostInterval
+	};
+	const budget = resolveAutocaptureTimeout(config) - AUTOCAPTURE_SAFETY_MARGIN_MS;
+	if (!params.showCaptureResultPreview) return {
+		mode: "countdown",
 		framesAggregationInterval: params.framesAggregationIntervalMs
 	};
+	if (budget < MIN_EXPERIMENT_AUTOCAPTURE_BUDGET_MS) return {
+		mode: "countdown",
+		framesAggregationInterval: DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval
+	};
+	let captureWindowMs = params.framesAggregationIntervalMs;
+	let optimizingDwellMs = params.resultPreviewDwellMs;
+	if (captureWindowMs + optimizingDwellMs > budget) {
+		captureWindowMs = Math.floor(budget / 2);
+		optimizingDwellMs = captureWindowMs;
+	}
+	return {
+		mode: "optimizing",
+		framesAggregationInterval: captureWindowMs + optimizingDwellMs,
+		captureWindowMs,
+		optimizingDwellMs
+	};
 }
 /**
 * Single source of truth for the WASM ID-capture thresholds passed to
@@ -41,9 +165,11 @@ function resolveCaptureResultPreviewTreatment(config) {
 * 3000ms) — with precedence:
 *
 * 1. An explicit `config.thresholds.framesAggregationInterval` (host/headless
-*    override) always wins — including when allocated to the treatment arm,
-*    which then runs the treatment UI on the host's aggregation window.
-* 2. Otherwise, the IDC-05 experiment's `framesAggregationInterval`.
+*    override) always wins. Such a session never runs the IDC-05 treatment
+*    (see `resolveCaptureOptimizingTreatment`), so the override is the whole
+*    window, undivided.
+* 2. Otherwise, the IDC-05-resolved interval — the summed split window in the
+*    treatment arm, the plain interval in the countdown arm.
 * 3. Otherwise, the canonical default.
 *
 * `idDetectedTimeout`/`autocaptureTimeout` are derived here too (from
@@ -64,7 +190,7 @@ function resolveIdCaptureThresholds(config, experimentInterval) {
 		...config.thresholds,
 		framesAggregationInterval: config.thresholds?.framesAggregationInterval ?? experimentInterval ?? DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval,
 		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? (config.deviceIdleTimeout ?? 10) * 1e3,
-		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? (config.autoCaptureTimeout ?? 5) * 1e3
+		autocaptureTimeout: resolveAutocaptureTimeout(config)
 	};
 }
 //#endregion
@@ -393,4 +519,4 @@ async function addBarcode(params) {
 	return res.data;
 }
 //#endregion
-export { processId as a, stopStream as c, validateUploadResponse as d, ID_ERROR_CODES as f, getIdCameraStream as g, CAPTURE_RESULT_PREVIEW as h, preloadIdRecordingProvider as i, uploadIdImage as l, resolveIdCaptureThresholds as m, barcodeToBase64 as n, startRecordingSession as o, resolveCaptureResultPreviewTreatment as p, initializeIdCapture as r, stopRecording as s, addBarcode as t, uploadManualIdFile as u };
+export { getIdCameraStream as _, processId as a, stopStream as c, validateUploadResponse as d, ID_ERROR_CODES as f, OPTIMIZING_WATCHDOG_MARGIN_MS as g, CAPTURE_OPTIMIZING as h, preloadIdRecordingProvider as i, uploadIdImage as l, resolveIdCaptureThresholds as m, barcodeToBase64 as n, startRecordingSession as o, resolveCaptureOptimizingTreatment as p, initializeIdCapture as r, stopRecording as s, addBarcode as t, uploadManualIdFile as u };