@incodetech/core 0.0.0-dev-20260911-aec162f0 → 0.0.0-dev-20260914-8aef7789

package/dist/createCameraCycleOwnership-DQ5-F2oW.esm.js

@@ -0,0 +1,826 @@
+import { c as CAMERA_CYCLE_OWNERSHIP_DOMAIN, l as getCameraCycleOwnershipDomain, s as wasmRuntime } from "./warmup-CUUnwYxe.esm.js";
+import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+//#region ../infra/src/capabilities/ICameraCycleCapability.ts
+/**
+* Fixed protected-endpoint identifiers owned by ml-wasm-kit.
+*
+* Keep these values aligned with `ProtectedEndpointCatalog`; callers must not
+* invent endpoint ids or pass raw URLs into the protected upload path.
+*/
+const PROTECTED_CAPTURE_TARGET = {
+	selfie: 1,
+	authentication: 2,
+	frontId: 3,
+	backId: 4,
+	frontSecondId: 5,
+	backSecondId: 6
+};
+//#endregion
+//#region src/internal/manualReview/manualReviewService.ts
+async function flagFaceManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualSelfieCheckNeeded: true });
+	} catch {}
+}
+async function flagIdManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualIdCheckNeeded: true });
+	} catch {}
+}
+//#endregion
+//#region ../infra/src/media/imageFile.ts
+const DEFAULT_IMAGE_MIME_TYPE = "image/jpeg";
+const DEFAULT_IMAGE_QUALITY = .92;
+const canNormalizeImageFile = (file) => file.type.startsWith("image/") && typeof document !== "undefined" && typeof Image !== "undefined" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
+const readFileAsDataUrl = (file) => new Promise((resolve, reject) => {
+	const reader = new FileReader();
+	reader.onload = () => {
+		const result = reader.result;
+		if (typeof result === "string") {
+			resolve(result);
+			return;
+		}
+		reject(/* @__PURE__ */ new Error("FileReader produced non-string result"));
+	};
+	reader.onerror = () => {
+		reject(reader.error ?? /* @__PURE__ */ new Error("FileReader failed"));
+	};
+	reader.readAsDataURL(file);
+});
+const loadImage = (url) => new Promise((resolve, reject) => {
+	const image = new Image();
+	image.onload = () => resolve(image);
+	image.onerror = () => reject(/* @__PURE__ */ new Error("Image decoding failed"));
+	image.src = url;
+});
+const fileToCanvasDataUrl = async (file, options) => {
+	const objectUrl = URL.createObjectURL(file);
+	try {
+		const image = await loadImage(objectUrl);
+		const width = image.naturalWidth || image.width;
+		const height = image.naturalHeight || image.height;
+		if (width <= 0 || height <= 0) return readFileAsDataUrl(file);
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext("2d");
+		if (!context) return readFileAsDataUrl(file);
+		context.fillStyle = "#fff";
+		context.fillRect(0, 0, width, height);
+		context.drawImage(image, 0, 0, width, height);
+		return canvas.toDataURL(options.mimeType ?? DEFAULT_IMAGE_MIME_TYPE, options.quality ?? DEFAULT_IMAGE_QUALITY);
+	} finally {
+		URL.revokeObjectURL(objectUrl);
+	}
+};
+const imageFileToDataUrl = async (file, options = {}) => {
+	if (!canNormalizeImageFile(file)) return readFileAsDataUrl(file);
+	try {
+		return await fileToCanvasDataUrl(file, options);
+	} catch {
+		return readFileAsDataUrl(file);
+	}
+};
+//#endregion
+//#region ../infra/src/providers/wasm/CameraCycleProvider.ts
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : null;
+}
+function responseData(value) {
+	const response = asRecord(value);
+	return asRecord(response?.data) ?? response ?? {};
+}
+function optionalString(value, key) {
+	return typeof value[key] === "string" ? value[key] : void 0;
+}
+function optionalNumber(value, key) {
+	return typeof value[key] === "number" && Number.isFinite(value[key]) ? value[key] : void 0;
+}
+function optionalBoolean(value, key) {
+	return typeof value[key] === "boolean" ? value[key] : void 0;
+}
+function optionalStringArray(value, key) {
+	const candidate = value[key];
+	return Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? [...candidate] : void 0;
+}
+function assertResponseTarget(raw, target) {
+	const response = asRecord(raw);
+	const data = asRecord(response?.data);
+	for (const reported of [response?.target, data?.target]) if (reported !== void 0 && reported !== target) throw new Error("[Incode SDK] Protected response target mismatch.");
+}
+function sanitizeSelfie(raw) {
+	const data = responseData(raw);
+	return {
+		kind: "selfie",
+		target: PROTECTED_CAPTURE_TARGET.selfie,
+		confidence: optionalNumber(data, "confidence"),
+		isBright: optionalBoolean(data, "isBright"),
+		hasLenses: optionalBoolean(data, "hasLenses"),
+		hasFaceMask: optionalBoolean(data, "hasFaceMask"),
+		hasClosedEyes: optionalBoolean(data, "hasClosedEyes"),
+		hasHeadCover: optionalBoolean(data, "hasHeadCover"),
+		sessionStatus: optionalString(data, "sessionStatus")
+	};
+}
+function sanitizeAuthentication(raw) {
+	const data = responseData(raw);
+	const status = optionalString(data, "overallStatus");
+	const captureAttemptsLimit = asRecord(data.captureAttemptsLimit);
+	const error = asRecord(data.error);
+	return {
+		kind: "authentication",
+		target: PROTECTED_CAPTURE_TARGET.authentication,
+		overallStatus: status === "PASS" || status === "FAIL" ? status : void 0,
+		attemptsRemaining: optionalNumber(data, "attemptsRemaining") ?? (captureAttemptsLimit ? optionalNumber(captureAttemptsLimit, "remaining") : void 0),
+		errorName: optionalString(data, "errorName") ?? (error ? optionalString(error, "name") : void 0)
+	};
+}
+function sanitizeId(raw, target) {
+	const data = responseData(raw);
+	const side = optionalString(data, "side");
+	return {
+		kind: "id",
+		target,
+		failReason: optionalString(data, "failReason"),
+		side: side === "front" || side === "back" ? side : void 0,
+		isDocumentExpired: optionalBoolean(data, "isDocumentExpired"),
+		classification: optionalBoolean(data, "classification"),
+		readability: optionalBoolean(data, "readability"),
+		idQualityAttemptApproved: optionalBoolean(data, "idQualityAttemptApproved"),
+		sharpness: optionalNumber(data, "sharpness"),
+		glare: optionalNumber(data, "glare"),
+		skipGlareFront: optionalBoolean(data, "skipGlareFront"),
+		skipGlareBack: optionalBoolean(data, "skipGlareBack"),
+		showMandatoryConsent: optionalBoolean(data, "showMandatoryConsent"),
+		typeOfId: optionalString(data, "typeOfId"),
+		skipBackIdCapture: optionalBoolean(data, "skipBackIdCapture"),
+		regulationType: optionalString(data, "regulationType"),
+		countryCode: optionalString(data, "countryCode"),
+		acceptedDocuments: optionalStringArray(data, "acceptedDocuments"),
+		forceFrontIdCapture: optionalBoolean(data, "forceFrontIdCapture"),
+		idValidationCompleted: optionalBoolean(data, "idValidationCompleted"),
+		sessionStatus: optionalString(data, "sessionStatus"),
+		success: optionalBoolean(data, "success")
+	};
+}
+function sanitizeProtectedResponse(request, raw) {
+	assertResponseTarget(raw, request.target);
+	switch (request.target) {
+		case PROTECTED_CAPTURE_TARGET.selfie: return sanitizeSelfie(raw);
+		case PROTECTED_CAPTURE_TARGET.authentication: return sanitizeAuthentication(raw);
+		case PROTECTED_CAPTURE_TARGET.frontId:
+		case PROTECTED_CAPTURE_TARGET.backId:
+		case PROTECTED_CAPTURE_TARGET.frontSecondId:
+		case PROTECTED_CAPTURE_TARGET.backSecondId: return sanitizeId(raw, request.target);
+	}
+}
+var CameraCycleProvider = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+		this[CAMERA_CYCLE_OWNERSHIP_DOMAIN] = getCameraCycleOwnershipDomain(runtime);
+	}
+	adoptStream(stream, constraints, options) {
+		return this.runtime.adoptCameraStream(stream, constraints, options);
+	}
+	setWorkflowConsuming(workflow, consuming) {
+		if (consuming && (workflow === 2 || workflow === 3)) throw new Error("[Incode SDK] Protected still capture is unavailable for video-selfie workflows.");
+		return this.runtime.setWorkflowConsuming(workflow, consuming);
+	}
+	captureProtectedFrame(target) {
+		return this.runtime.captureProtectedFrame(target);
+	}
+	paintFrameToCanvas(canvas, options) {
+		return this.runtime.paintFrameToCanvas(canvas, options);
+	}
+	getCaptureSize() {
+		return this.runtime.getCaptureSize();
+	}
+	getUnprotectedStream() {
+		return this.runtime.getUnprotectedStream();
+	}
+	async postProtectedRequest(request) {
+		return sanitizeProtectedResponse(request, await this.runtime.postProtectedRequest(request));
+	}
+	release() {
+		this.runtime.releaseCameraCycle();
+	}
+};
+const cameraCycleProvider = new CameraCycleProvider();
+//#endregion
+//#region src/internal/cameraCycle/protectedAttemptActor.ts
+/**
+* Runs the protected lifecycle inside an owning callback actor. Keeping the
+* implementation callable lets domain controllers compose the exact same
+* lifecycle without placing its capability-bearing input in machine context.
+*/
+const runProtectedAttempt = ({ input, sendBack, receive }) => {
+	const abortController = new AbortController();
+	let active = true;
+	let backgrounded = input.initiallyBackgrounded === true;
+	let ready = false;
+	let committed = false;
+	let finalized = false;
+	let deliveryInFlight = false;
+	let delivered = false;
+	let consuming = false;
+	let recorderStarted = false;
+	let recorderOperationInFlight = false;
+	let recorderPrepared = false;
+	let preparedRecording = {};
+	let pocCompleted = false;
+	let recorderResumedAfterPoc = false;
+	let postPocDisplayStream = null;
+	let finalizeDeferred = false;
+	let pendingReadyStream = null;
+	let pendingDeliveryEvent = null;
+	let visibilityGeneration = 0;
+	let unadoptedStream = input.streamSource.kind === "preAcquired" ? input.streamSource.stream : null;
+	let resourcesReleased = false;
+	let cycleTransferred = false;
+	let commandQueue = Promise.resolve();
+	const now = input.getTimestamp ?? getTimestamp;
+	let startupStartedAt;
+	const startupTiming = {};
+	const measure = (operation) => {
+		const startedAt = now();
+		return {
+			value: operation(),
+			durationMs: Math.max(0, now() - startedAt)
+		};
+	};
+	const reportStartupTiming = (consumeMs, totalMs) => {
+		if (startupStartedAt === void 0 || !input.onStartupTiming) return;
+		try {
+			input.onStartupTiming({
+				acquireMs: startupTiming.acquireMs ?? 0,
+				adoptMs: startupTiming.adoptMs ?? 0,
+				prcMs: startupTiming.prcMs ?? 0,
+				displayStreamMs: startupTiming.displayStreamMs ?? 0,
+				configureMs: startupTiming.configureMs ?? 0,
+				recorderMs: startupTiming.recorderMs ?? 0,
+				consumeMs,
+				totalMs
+			});
+		} catch {}
+	};
+	const sendParent = (event) => {
+		sendBack(event);
+	};
+	const releaseRawStream = (stream) => {
+		try {
+			input.releaseUnadoptedStream(stream);
+		} catch {}
+	};
+	const reportFailure = (stage, code) => {
+		if (!active) return;
+		sendParent({
+			type: "PROTECTED_ATTEMPT_FAILED",
+			attemptId: input.attemptId,
+			failure: {
+				stage,
+				code
+			}
+		});
+	};
+	const releaseResources = () => {
+		if (resourcesReleased) return;
+		resourcesReleased = true;
+		abortController.abort();
+		if (consuming) {
+			try {
+				input.cycle.setWorkflowConsuming(input.workflow, false);
+			} catch {}
+			consuming = false;
+		}
+		try {
+			input.recorder.dispose();
+		} catch {}
+		recorderStarted = false;
+		pendingReadyStream = null;
+		postPocDisplayStream = null;
+		pendingDeliveryEvent = null;
+		finalizeDeferred = false;
+		if (unadoptedStream) releaseRawStream(unadoptedStream);
+		unadoptedStream = null;
+		if (cycleTransferred) input.cycleOwnership.releaseByAttempt();
+		else input.cycleOwnership.releaseByController();
+	};
+	const deactivate = () => {
+		if (!active && resourcesReleased) return;
+		active = false;
+		ready = false;
+		releaseResources();
+	};
+	const failClosed = (stage, code) => {
+		reportFailure(stage, code);
+		deactivate();
+	};
+	const stopConsuming = () => {
+		if (!consuming) return true;
+		try {
+			if (!input.cycle.setWorkflowConsuming(input.workflow, false)) return false;
+		} catch {
+			return false;
+		}
+		consuming = false;
+		return true;
+	};
+	const pauseRecorderForBackground = () => {
+		if (recorderOperationInFlight) return;
+		if (!recorderStarted) return;
+		if (recorderPrepared && !recorderResumedAfterPoc) return;
+		try {
+			input.recorder.pauseForBackground();
+		} catch {
+			reportFailure("recorder", "protected-attempt-background-pause-failed");
+		}
+	};
+	const startConsumingAndAnnounceReady = (displayStream) => {
+		const consume = measure(() => input.cycle.setWorkflowConsuming(input.workflow, true));
+		if (!consume.value) {
+			failClosed("consume", "protected-attempt-consume-failed");
+			return false;
+		}
+		const startupTotalMs = startupStartedAt === void 0 ? 0 : Math.max(0, now() - startupStartedAt);
+		consuming = true;
+		ready = true;
+		pendingReadyStream = null;
+		if (input.resourceSink) {
+			input.resourceSink.ready(displayStream);
+			sendParent({
+				type: "PROTECTED_ATTEMPT_READY_SIGNAL",
+				attemptId: input.attemptId
+			});
+		} else sendParent({
+			type: "PROTECTED_ATTEMPT_READY",
+			attemptId: input.attemptId,
+			displayStream
+		});
+		reportStartupTiming(consume.durationMs, startupTotalMs);
+		return true;
+	};
+	const start = async () => {
+		let stage = "acquire";
+		try {
+			startupStartedAt = now();
+			const acquisitionStartedAt = now();
+			const acquired = input.streamSource.kind === "preAcquired" ? {
+				stream: input.streamSource.stream,
+				constraints: input.streamSource.constraints
+			} : await input.streamSource.acquire(abortController.signal);
+			startupTiming.acquireMs = Math.max(0, now() - acquisitionStartedAt);
+			if (!active || abortController.signal.aborted) {
+				releaseRawStream(acquired.stream);
+				return;
+			}
+			unadoptedStream = acquired.stream;
+			stage = "adopt";
+			if (input.beforeAdopt) {
+				await input.beforeAdopt(acquired.stream);
+				if (!active || abortController.signal.aborted) return;
+			}
+			const adoption = measure(() => input.cycle.adoptStream(acquired.stream, acquired.constraints, input.captureOptions));
+			startupTiming.adoptMs = adoption.durationMs;
+			if (!adoption.value) throw new Error("protected camera stream adoption was rejected");
+			unadoptedStream = null;
+			input.cycleOwnership.transferToAttempt();
+			cycleTransferred = true;
+			stage = "prc";
+			const prcStartedAt = now();
+			await input.runPrc();
+			startupTiming.prcMs = Math.max(0, now() - prcStartedAt);
+			if (!active) return;
+			const displayStreamResult = measure(() => input.cycle.getUnprotectedStream());
+			startupTiming.displayStreamMs = displayStreamResult.durationMs;
+			const displayStream = displayStreamResult.value;
+			if (!displayStream) throw new Error("protected camera cycle did not provide a stream");
+			stage = "configure";
+			const configureStartedAt = now();
+			await input.configureWorkflow();
+			startupTiming.configureMs = Math.max(0, now() - configureStartedAt);
+			if (!active) return;
+			recorderOperationInFlight = true;
+			const recorderStartedAt = now();
+			try {
+				await input.recorder.start(displayStream);
+				recorderStarted = input.recorder.mode !== "none";
+			} catch {
+				try {
+					input.recorder.dispose();
+				} catch {}
+				recorderStarted = false;
+			} finally {
+				startupTiming.recorderMs = Math.max(0, now() - recorderStartedAt);
+				recorderOperationInFlight = false;
+			}
+			if (!active) return;
+			if (backgrounded) {
+				pauseRecorderForBackground();
+				pendingReadyStream = displayStream;
+				return;
+			}
+			stage = "consume";
+			startConsumingAndAnnounceReady(displayStream);
+		} catch {
+			if (!active) return;
+			failClosed(stage, `protected-attempt-${stage}-failed`);
+		}
+	};
+	const commitAutoCapture = (preview) => {
+		if (!active || !ready || backgrounded || committed) return;
+		if (!stopConsuming()) {
+			failClosed("consume", "protected-attempt-stop-consuming-failed");
+			return;
+		}
+		committed = true;
+		if (input.resourceSink) {
+			input.resourceSink.autoCommitted(preview);
+			sendParent({
+				type: "PROTECTED_AUTO_COMMITTED_SIGNAL",
+				attemptId: input.attemptId
+			});
+		} else sendParent({
+			type: "PROTECTED_AUTO_COMMITTED",
+			attemptId: input.attemptId,
+			preview
+		});
+	};
+	const commitManualCapture = () => {
+		if (!active || !ready || backgrounded || committed) return;
+		let preview;
+		try {
+			preview = input.cycle.captureProtectedFrame(input.target);
+		} catch {
+			reportFailure("manualCommit", "protected-attempt-manual-commit-refused");
+			return;
+		}
+		if (!stopConsuming()) {
+			failClosed("consume", "protected-attempt-stop-consuming-failed");
+			return;
+		}
+		committed = true;
+		if (input.resourceSink) {
+			input.resourceSink.manualCommitted(preview);
+			sendParent({
+				type: "PROTECTED_MANUAL_COMMITTED_SIGNAL",
+				attemptId: input.attemptId
+			});
+		} else sendParent({
+			type: "PROTECTED_MANUAL_COMMITTED",
+			attemptId: input.attemptId,
+			preview
+		});
+	};
+	const finalize = async () => {
+		if (!active || !ready || finalized) return;
+		if (backgrounded) {
+			finalizeDeferred = true;
+			return;
+		}
+		if (!committed) {
+			reportFailure("poc", "protected-attempt-not-committed");
+			return;
+		}
+		finalizeDeferred = false;
+		if (recorderStarted && !recorderPrepared) {
+			recorderOperationInFlight = true;
+			try {
+				preparedRecording = await input.recorder.prepareForPoc();
+				recorderPrepared = true;
+			} catch {
+				if (!active) return;
+				failClosed("recorder", "protected-attempt-recorder-finalize-failed");
+				return;
+			} finally {
+				recorderOperationInFlight = false;
+			}
+			if (!active) return;
+			if (backgrounded) {
+				pauseRecorderForBackground();
+				finalizeDeferred = true;
+				return;
+			}
+		}
+		if (!pocCompleted) {
+			try {
+				await input.runPoc();
+				pocCompleted = true;
+			} catch {
+				if (!active) return;
+				failClosed("poc", "protected-attempt-poc-failed");
+				return;
+			}
+			if (!active) return;
+			if (backgrounded) {
+				finalizeDeferred = true;
+				return;
+			}
+		}
+		let displayStream = postPocDisplayStream;
+		if (input.recorder.mode === "suspendResume" && recorderStarted && !recorderResumedAfterPoc) {
+			displayStream = input.cycle.getUnprotectedStream();
+			if (!displayStream) {
+				failClosed("recorder", "protected-attempt-resume-stream-missing");
+				return;
+			}
+			try {
+				recorderOperationInFlight = true;
+				await input.recorder.resumeAfterPoc(displayStream);
+				recorderResumedAfterPoc = true;
+				postPocDisplayStream = displayStream;
+			} catch {
+				if (!active) return;
+				failClosed("recorder", "protected-attempt-recorder-resume-failed");
+				return;
+			} finally {
+				recorderOperationInFlight = false;
+			}
+			if (!active) return;
+			if (backgrounded) {
+				pauseRecorderForBackground();
+				finalizeDeferred = true;
+				return;
+			}
+		}
+		finalized = true;
+		if (input.resourceSink) {
+			input.resourceSink.finalized(preparedRecording, displayStream);
+			sendParent({
+				type: "PROTECTED_ATTEMPT_FINALIZED_SIGNAL",
+				attemptId: input.attemptId
+			});
+		} else sendParent({
+			type: "PROTECTED_ATTEMPT_FINALIZED",
+			attemptId: input.attemptId,
+			recording: preparedRecording,
+			displayStream
+		});
+	};
+	const uploadProtected = async (command) => {
+		if (!active || !finalized || deliveryInFlight || delivered) return;
+		if (backgrounded) {
+			pendingDeliveryEvent = {
+				type: "PROTECTED_ATTEMPT_FAILED",
+				attemptId: input.attemptId,
+				failure: {
+					stage: "upload",
+					code: "protected-attempt-backgrounded"
+				}
+			};
+			return;
+		}
+		if (command.request.target !== input.target) {
+			reportFailure("upload", "protected-attempt-target-mismatch");
+			return;
+		}
+		deliveryInFlight = true;
+		try {
+			const result = await input.cycle.postProtectedRequest(command.request);
+			if (active) {
+				if (result.target !== input.target) {
+					reportFailure("upload", "protected-attempt-result-target-mismatch");
+					return;
+				}
+				delivered = true;
+				const event = input.resourceSink ? (() => {
+					input.resourceSink.uploadDone(result);
+					return {
+						type: "PROTECTED_UPLOAD_DONE_SIGNAL",
+						attemptId: input.attemptId
+					};
+				})() : {
+					type: "PROTECTED_UPLOAD_DONE",
+					attemptId: input.attemptId,
+					result
+				};
+				if (backgrounded) pendingDeliveryEvent = event;
+				else sendParent(event);
+			}
+		} catch {
+			if (backgrounded) pendingDeliveryEvent = {
+				type: "PROTECTED_ATTEMPT_FAILED",
+				attemptId: input.attemptId,
+				failure: {
+					stage: "upload",
+					code: "protected-attempt-upload-failed"
+				}
+			};
+			else reportFailure("upload", "protected-attempt-upload-failed");
+		} finally {
+			deliveryInFlight = false;
+		}
+	};
+	const uploadFaceResults = async (command) => {
+		if (!active || !finalized || deliveryInFlight || delivered) return;
+		if (backgrounded) {
+			pendingDeliveryEvent = {
+				type: "PROTECTED_ATTEMPT_FAILED",
+				attemptId: input.attemptId,
+				failure: {
+					stage: "upload",
+					code: "protected-attempt-backgrounded"
+				}
+			};
+			return;
+		}
+		if (input.target !== PROTECTED_CAPTURE_TARGET.selfie && input.target !== PROTECTED_CAPTURE_TARGET.authentication) {
+			reportFailure("upload", "protected-attempt-target-mismatch");
+			return;
+		}
+		if (!input.faceResults) {
+			reportFailure("upload", "protected-attempt-face-results-unavailable");
+			return;
+		}
+		deliveryInFlight = true;
+		try {
+			await input.faceResults.postFaceResults(command.config);
+			if (active) {
+				delivered = true;
+				const result = {
+					kind: "onDeviceFace",
+					target: input.target
+				};
+				const event = input.resourceSink ? (() => {
+					input.resourceSink.uploadDone(result);
+					return {
+						type: "PROTECTED_UPLOAD_DONE_SIGNAL",
+						attemptId: input.attemptId
+					};
+				})() : {
+					type: "PROTECTED_UPLOAD_DONE",
+					attemptId: input.attemptId,
+					result
+				};
+				if (backgrounded) pendingDeliveryEvent = event;
+				else sendParent(event);
+			}
+		} catch {
+			if (backgrounded) pendingDeliveryEvent = {
+				type: "PROTECTED_ATTEMPT_FAILED",
+				attemptId: input.attemptId,
+				failure: {
+					stage: "upload",
+					code: "protected-attempt-upload-failed"
+				}
+			};
+			else reportFailure("upload", "protected-attempt-upload-failed");
+		} finally {
+			deliveryInFlight = false;
+		}
+	};
+	const handleCommand = async (command, receivedVisibilityGeneration) => {
+		if (!active) return;
+		switch (command.type) {
+			case "AUTO_CAPTURE": {
+				const preview = input.capturePresentationFrame?.();
+				if (preview) commitAutoCapture(preview);
+				return;
+			}
+			case "AUTO_CAPTURED":
+				commitAutoCapture(command.preview);
+				return;
+			case "MANUAL_CAPTURE":
+				commitManualCapture();
+				return;
+			case "FINALIZE":
+				await finalize();
+				return;
+			case "UPLOAD_PROTECTED":
+				await uploadProtected(command);
+				return;
+			case "UPLOAD_FACE_RESULTS":
+				await uploadFaceResults(command);
+				return;
+			case "BACKGROUND": return;
+			case "FOREGROUND": {
+				if (!backgrounded) return;
+				if (receivedVisibilityGeneration !== visibilityGeneration) return;
+				let resumedStream = null;
+				if (recorderStarted && (!recorderPrepared || recorderResumedAfterPoc)) {
+					resumedStream = input.cycle.getUnprotectedStream();
+					if (!resumedStream) {
+						reportFailure("recorder", "protected-attempt-foreground-stream-missing");
+						return;
+					}
+					recorderOperationInFlight = true;
+					try {
+						await input.recorder.resumeFromBackground(resumedStream);
+						if (!active) return;
+						if (receivedVisibilityGeneration !== visibilityGeneration) {
+							recorderOperationInFlight = false;
+							pauseRecorderForBackground();
+							return;
+						}
+						if (pocCompleted && recorderResumedAfterPoc) postPocDisplayStream = resumedStream;
+					} catch {
+						if (!active) return;
+						reportFailure("recorder", "protected-attempt-background-resume-failed");
+						return;
+					} finally {
+						recorderOperationInFlight = false;
+					}
+				}
+				backgrounded = false;
+				if (pendingReadyStream) {
+					const readyStream = resumedStream ?? pendingReadyStream;
+					try {
+						if (!startConsumingAndAnnounceReady(readyStream)) return;
+					} catch {
+						failClosed("consume", "protected-attempt-consume-failed");
+						return;
+					}
+				}
+				if (finalizeDeferred) {
+					await finalize();
+					if (!active || backgrounded) return;
+				}
+				if (pendingDeliveryEvent) {
+					const event = pendingDeliveryEvent;
+					pendingDeliveryEvent = null;
+					sendParent(event);
+				}
+				return;
+			}
+			case "RELEASE": return;
+		}
+	};
+	let startup = backgrounded ? null : start();
+	const ensureStartup = () => {
+		startup ??= start();
+		return startup;
+	};
+	receive((command) => {
+		if (command.type === "RELEASE") {
+			if (!active) return;
+			deactivate();
+			sendParent({
+				type: "PROTECTED_ATTEMPT_RELEASED",
+				attemptId: input.attemptId
+			});
+			return;
+		}
+		if (command.type === "BACKGROUND") {
+			if (!active) return;
+			backgrounded = true;
+			visibilityGeneration += 1;
+			pauseRecorderForBackground();
+			return;
+		}
+		if (!active) return;
+		const receivedVisibilityGeneration = command.type === "FOREGROUND" ? visibilityGeneration : void 0;
+		if (command.type === "FOREGROUND" && startup === null) {
+			if (receivedVisibilityGeneration !== visibilityGeneration) return;
+			backgrounded = false;
+			commandQueue = commandQueue.then(async () => {
+				await ensureStartup();
+			}).catch(() => {
+				failClosed("acquire", "protected-attempt-command-failed");
+			});
+			return;
+		}
+		commandQueue = commandQueue.then(async () => {
+			await ensureStartup();
+			await handleCommand(command, receivedVisibilityGeneration);
+		}).catch(() => {
+			failClosed("internal", "protected-attempt-command-failed");
+		});
+	});
+	return deactivate;
+};
+fromCallback(runProtectedAttempt);
+//#endregion
+//#region ../infra/src/providers/wasm/createCameraCycleOwnership.ts
+/** Creates an attempt lease in the underlying runtime's ownership domain. */
+function createCameraCycleOwnership(cycle) {
+	const domain = getCameraCycleOwnershipDomain(cycle);
+	const creationSnapshot = domain.snapshot();
+	const owner = Symbol("protectedCameraCycleOwner");
+	let state = "controller";
+	const releaseNative = () => {
+		try {
+			cycle.release();
+		} catch {}
+	};
+	return {
+		transferToAttempt() {
+			if (state !== "controller") return;
+			state = "attempt";
+			domain.transfer(owner);
+		},
+		releaseByController() {
+			if (state !== "controller") return;
+			state = "released";
+			if (domain.releaseController(creationSnapshot.generation, creationSnapshot.activeOwner === void 0)) releaseNative();
+		},
+		releaseByAttempt() {
+			if (state !== "attempt") return;
+			state = "released";
+			if (domain.releaseAttempt(owner)) releaseNative();
+		}
+	};
+}
+//#endregion
+export { flagFaceManualReview as a, imageFileToDataUrl as i, runProtectedAttempt as n, flagIdManualReview as o, cameraCycleProvider as r, PROTECTED_CAPTURE_TARGET as s, createCameraCycleOwnership as t };