@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/multipartRecordingService-OEgIRvqC.esm.js

@@ -0,0 +1,605 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
+import { a as isIOS, t as isAndroid } from "./platform-DkcRc9JV.esm.js";
+//#region ../infra/src/media/mediaRecorderOptions.ts
+/**
+* Picks a `MediaRecorder` mime type the current browser actually supports.
+* WebM avoids Safari's fragmented-MP4 unknown-duration metadata on versions
+* that can record it; older Safari versions fall back to MP4. Returns '' when
+* none match.
+*/
+function getSupportedMediaRecorderMimeType() {
+	for (const type of [
+		"video/webm",
+		"video/webm;codecs=vp9",
+		"video/webm;codecs=vp8",
+		"video/mp4"
+	]) if (MediaRecorder.isTypeSupported(type)) return type;
+	return "";
+}
+/**
+* Mime type for the multipart (video-selfie-service) recorder. Android
+* Chromium gets hardware H.264 in fragmented MP4 first — the fragment shape
+* the service already ingests from Safari. Measured on a Galaxy S21 under ID
+* detection load (ENG-55397): 720p VP8 dropped 16% of frames, H.264 dropped
+* none. Everything else keeps the WebM-first order.
+*/
+function getMultipartRecorderMimeType() {
+	if (isAndroid() && MediaRecorder.isTypeSupported("video/mp4;codecs=avc1")) return "video/mp4;codecs=avc1";
+	return getSupportedMediaRecorderMimeType();
+}
+/**
+* `MediaRecorder` options tuned per platform — a higher bitrate on iOS, lower
+* elsewhere — paired with the supported mime type.
+*/
+function getAdaptiveMediaRecorderOptions() {
+	const mimeType = getSupportedMediaRecorderMimeType();
+	if (isIOS()) return {
+		mimeType,
+		videoBitsPerSecond: 1e6,
+		bitsPerSecond: 1e6
+	};
+	return {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	};
+}
+//#endregion
+//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
+/**
+* How often `MediaRecorder` hands us buffered data (incremental blobs).
+* 500 ms keeps each blob — and therefore each upload chunk — small: less
+* tail lost when a session is interrupted, and a smaller first blob (init
+* header + keyframe), which is the largest and most timeout-prone chunk.
+* Not lower: request rate doubles per halving, and browsers stop honoring
+* very small timeslices reliably.
+*/
+const TIMESLICE_MS = 500;
+/**
+* Encoder target for the full video-selfie session. Higher than the
+* short-clip liveness path (0.5–1 Mbps) so a multi-minute session keeps
+* usable quality. It's a ceiling — a still scene still encodes well below it.
+*/
+const VIDEO_BITS_PER_SECOND = 25e5;
+/**
+* Records a stream and emits every `MediaRecorder` timeslice blob as its own
+* part, in order. Each blob is a whole container fragment (WebM cluster /
+* fMP4 `moof`+`mdat`), which is the property the video-selfie-service's
+* gap-splicing depends on — parts must never cut a fragment at a byte
+* offset. The service stages sub-5 MiB chunks and combines them server-side,
+* so emitting the smallest whole-fragment unit (~0.5 s of video) maximizes
+* what an interrupted session can salvage.
+*
+* Page-lifecycle orchestration lives in Core: it pauses this recorder before a
+* backgrounded camera can stall, restores the camera/compositor, and only then
+* resumes this same media container.
+*/
+var MultipartRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.partNumber = 0;
+		this.onPart = null;
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		this.partNumber = 0;
+		this.onPart = onPart;
+		try {
+			this.mimeType = getMultipartRecorderMimeType();
+			const recorder = new MediaRecorder(stream.clone(), {
+				mimeType: this.mimeType,
+				videoBitsPerSecond: VIDEO_BITS_PER_SECOND
+			});
+			recorder.ondataavailable = (event) => {
+				if (event.data.size > 0 && this.onPart) {
+					this.partNumber += 1;
+					this.onPart({
+						chunk: event.data,
+						partNumber: this.partNumber
+					});
+				}
+			};
+			recorder.onerror = (event) => {
+				const detail = event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type;
+				this._error = `Recording error: ${detail}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start(TIMESLICE_MS);
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to start recording: ${detail}`;
+			this._hasError = true;
+		}
+	}
+	pauseRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "paused") return true;
+		if (recorder.state !== "recording") return false;
+		try {
+			recorder.pause();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to pause recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	resumeRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "recording") return true;
+		if (recorder.state !== "paused") return false;
+		try {
+			recorder.resume();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to resume recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	stopRecording() {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve) => {
+			if (recorder && this._isRecording) {
+				recorder.onstop = () => {
+					resolve();
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve();
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	reset() {
+		const recorder = this.mediaRecorder;
+		if (recorder) {
+			recorder.ondataavailable = null;
+			recorder.onerror = null;
+			recorder.onstop = null;
+			if (recorder.state !== "inactive") recorder.stop();
+			recorder.stream.getTracks().forEach((track) => track.stop());
+			this.mediaRecorder = null;
+		}
+		this.onPart = null;
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+};
+//#endregion
+//#region ../infra/src/providers/browser/BrowserNetworkStatusProvider.ts
+var BrowserNetworkStatusProvider = class {
+	onOnline(listener) {
+		if (typeof window === "undefined" || typeof window.addEventListener !== "function") return () => {};
+		window.addEventListener("online", listener);
+		return () => {
+			window.removeEventListener("online", listener);
+		};
+	}
+};
+//#endregion
+//#region src/internal/recordings/videoSelfieUploadService.ts
+/**
+* Opens a scoped multipart video upload session. Idempotent server-side: if
+* an upload is already in progress for the `(session, scope)` pair, the same `uploadId`
+* comes back along with the parts already stored (`parts` non-empty) — but
+* always with a fresh `epoch` that locks out whoever held the previous one.
+*/
+async function initiateVideoSelfieUpload(scope = "videoselfie") {
+	const response = await api.post(endpoints.videoSelfieUploadInitiate, void 0, { query: { scope } });
+	return {
+		uploadId: response.data.uploadId,
+		epoch: response.data.epoch,
+		scope,
+		parts: response.data.parts ?? []
+	};
+}
+/**
+* Uploads a single chunk as a multipart part. The body is the raw video bytes
+* (no base64, no client-side encryption — encryption at rest is server-side
+* S3 SSE). Every part except the last must be >= 5 MiB (enforced
+* server-side). Returns the part number + `etag` needed to complete the
+* upload. Rejects with a `409` status when a newer initiate fenced this
+* session out.
+*/
+async function uploadVideoSelfiePart(session, partNumber, chunk) {
+	const response = await api.post(endpoints.videoSelfieUploadPart, chunk, {
+		query: {
+			uploadId: session.uploadId,
+			epoch: session.epoch,
+			partNumber,
+			scope: session.scope
+		},
+		headers: { "Content-Type": "application/octet-stream" }
+	});
+	return {
+		partNumber: response.data.partNumber,
+		etag: response.data.etag
+	};
+}
+/**
+* Finalizes the upload. The service assembles from the parts it stored; the
+* optional `parts` list is deliberately NOT sent — chunks staged below the
+* S3 minimum are combined and renumbered server-side, so a client-side list
+* could contradict the authoritative one. Safe to repeat if the response
+* was lost. Returns the server-reported status. Rejects with `400` naming a
+* missing part when the sequence has a hole.
+*/
+async function completeVideoSelfieUpload(session) {
+	return (await api.post(endpoints.videoSelfieUploadComplete, {
+		uploadId: session.uploadId,
+		epoch: session.epoch
+	}, { query: { scope: session.scope } })).data.status;
+}
+/**
+* Discards an in-progress upload and everything already sent for it, so the
+* backend fails the upload straight away instead of waiting for its expiry.
+* Call when a recording is abandoned or its upload can no longer complete.
+*/
+async function abortVideoSelfieUpload(session) {
+	return (await api.post(endpoints.videoSelfieUploadAbort, {
+		uploadId: session.uploadId,
+		epoch: session.epoch
+	}, { query: { scope: session.scope } })).data.status;
+}
+//#endregion
+//#region src/internal/recordings/videoSelfieChunkUploader.ts
+/**
+* How many part uploads run concurrently. The service allows 10 rps with a
+* burst of 30 per session; a real recorder emits ~2 chunks/s, so this cap
+* only matters when a backlog is draining after a network stall.
+*/
+const MAX_IN_FLIGHT = 3;
+/** Attempts per chunk in the live round (first try + retries). */
+const MAX_ATTEMPTS = 4;
+/** Extra attempts per parked chunk during the final drain() round. */
+const DRAIN_ATTEMPTS = 2;
+const BACKOFF_BASE_MS = 500;
+const BACKOFF_CAP_MS = 8e3;
+/** Upper bound honored for a server-sent `Retry-After` (seconds). */
+const RETRY_AFTER_CAP_MS = 3e4;
+/**
+* Ceiling on un-acknowledged chunk bytes held in memory. On a network slower
+* than the encoder the backlog grows without bound; past this the upload
+* cannot realistically catch up, so the uploader fails instead of eating
+* memory on a low-end device. ~48 MiB ≈ 2.5 minutes of video at our bitrate.
+*/
+const MAX_BUFFERED_BYTES = 48 * 1024 * 1024;
+function httpStatusOf$1(error) {
+	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
+	return null;
+}
+function retryAfterMsOf(error) {
+	if (typeof error === "object" && error !== null && "headers" in error && typeof error.headers === "object") {
+		const headers = error.headers;
+		const seconds = Number(headers?.["retry-after"]);
+		if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
+	}
+	return null;
+}
+/**
+* Uploads video-selfie chunks with the client-side half of the service's
+* resilience contract (`video-selfie-service` README, "What a client can
+* rely on"):
+*
+* - **Keep-until-ack** — every chunk is held in memory until its upload
+*   returns 200 (a hole in the sequence can only be filled by that exact
+*   data). Acked bytes are durable in S3 (stored as a part or staged), so
+*   the blob is released the moment the ack lands.
+* - **Retry with backoff** — transient failures (network error/timeout,
+*   408, 429, 5xx) retry the same bytes under the same partNumber with
+*   exponential backoff + full jitter; 429 honors the server's
+*   `Retry-After`. Chunks may land out of order — the service stages them.
+* - **Park, then drain** — a chunk that exhausts its live retries is parked
+*   (blob kept) without failing the recording; {@link drain} gives every
+*   parked chunk a final round once recording stops, so a mid-recording
+*   network outage only fails the upload if it persists to the end. A
+*   browser `online` event un-parks early: parked chunks get a fresh live
+*   round as soon as connectivity returns instead of waiting for stop.
+* - **409 is fatal** — a newer initiate fenced this session out ("latest
+*   initiate wins"); no retry can succeed, so the uploader stops.
+* - **Bounded memory** — when un-acked bytes exceed the ceiling the
+*   uploader fails rather than buffering a runaway backlog.
+*/
+var VideoSelfieChunkUploader = class {
+	constructor(session, dependencies = {}) {
+		this.queue = [];
+		this.parked = [];
+		this.inFlight = 0;
+		this.bufferedBytes = 0;
+		this.fatal = false;
+		this.disposed = false;
+		this.tasks = [];
+		this.session = session;
+		this.timer = dependencies.timer ?? BrowserTimerProvider.getInstance();
+		this.jitter = dependencies.jitter ?? Math.random;
+		const networkStatus = dependencies.networkStatus ?? new BrowserNetworkStatusProvider();
+		this.unsubscribeOnline = networkStatus.onOnline(() => this.unparkEarly());
+	}
+	/** True once the upload cannot complete (fenced out or over the memory cap). */
+	get failed() {
+		return this.fatal;
+	}
+	/**
+	* Accepts the next chunk for upload. Non-blocking: the upload (and any
+	* retries) run in the background; failures surface through {@link failed}
+	* and {@link drain}.
+	*/
+	enqueue(partNumber, chunk) {
+		if (this.fatal || this.disposed) return;
+		this.bufferedBytes += chunk.size;
+		if (this.bufferedBytes > MAX_BUFFERED_BYTES) {
+			this.fatal = true;
+			return;
+		}
+		this.queue.push({
+			partNumber,
+			chunk,
+			attempts: 0
+		});
+		this.pump();
+	}
+	/**
+	* Waits for every accepted chunk to be acknowledged, giving parked chunks
+	* one final retry round. Returns `true` when all chunks landed and the
+	* upload can be completed.
+	*/
+	async drain() {
+		this.unsubscribeOnline();
+		await this.settleLiveRound();
+		while (!this.fatal && this.parked.length > 0) {
+			const chunk = this.parked.shift();
+			chunk.attempts = MAX_ATTEMPTS - DRAIN_ATTEMPTS;
+			this.queue.push(chunk);
+			this.pump();
+			await this.settleLiveRound();
+			if (this.parked.some((p) => p.partNumber === chunk.partNumber)) return false;
+		}
+		return !this.disposed && !this.fatal && this.parked.length === 0;
+	}
+	/** Cancels all pending work; held blobs are released. */
+	dispose() {
+		this.disposed = true;
+		this.queue = [];
+		this.parked = [];
+		this.unsubscribeOnline();
+	}
+	/**
+	* Connectivity is back (browser `online` event) — give parked chunks a
+	* fresh live round right away instead of holding them until {@link drain}.
+	* The event is only a hint: chunks that still fail simply park again.
+	*/
+	unparkEarly() {
+		if (this.fatal || this.disposed || this.parked.length === 0) return;
+		for (const chunk of this.parked.splice(0)) {
+			chunk.attempts = 0;
+			this.queue.push(chunk);
+		}
+		this.pump();
+	}
+	async settleLiveRound() {
+		while (this.tasks.length > 0) {
+			const snapshot = [...this.tasks];
+			await Promise.all(snapshot);
+			this.tasks = this.tasks.filter((task) => !snapshot.includes(task));
+		}
+	}
+	pump() {
+		while (!this.fatal && !this.disposed && this.inFlight < MAX_IN_FLIGHT && this.queue.length > 0) {
+			const chunk = this.queue.shift();
+			this.inFlight += 1;
+			const task = this.uploadWithRetry(chunk).finally(() => {
+				this.inFlight -= 1;
+				this.pump();
+			});
+			this.tasks.push(task);
+		}
+	}
+	async uploadWithRetry(pending) {
+		while (!this.disposed) {
+			pending.attempts += 1;
+			try {
+				await uploadVideoSelfiePart(this.session, pending.partNumber, pending.chunk);
+				this.bufferedBytes -= pending.chunk.size;
+				return;
+			} catch (error) {
+				const status = httpStatusOf$1(error);
+				if (status === 409) {
+					this.fatal = true;
+					return;
+				}
+				if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || pending.attempts >= MAX_ATTEMPTS) {
+					this.parked.push(pending);
+					return;
+				}
+				await this.delayBeforeRetry(pending.attempts, error);
+			}
+		}
+	}
+	delayBeforeRetry(attempt, error) {
+		const retryAfterMs = retryAfterMsOf(error);
+		const backoffCeiling = Math.min(BACKOFF_BASE_MS * 2 ** (attempt - 1), BACKOFF_CAP_MS);
+		const waitMs = retryAfterMs ?? backoffCeiling / 2 + this.jitter() * (backoffCeiling / 2);
+		return new Promise((resolve) => {
+			this.timer.setTimeout(resolve, waitMs);
+		});
+	}
+};
+//#endregion
+//#region src/internal/recordings/multipartRecordingService.ts
+/** Attempts for `complete` — documented safe to repeat if the response was lost. */
+const COMPLETE_ATTEMPTS = 3;
+const COMPLETE_BACKOFF_MS = 500;
+function httpStatusOf(error) {
+	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
+	return null;
+}
+/**
+* Records the camera on-device and streams it to the backend as it is
+* captured, using the video-selfie-service multipart upload protocol
+* (`/v1/video-upload/*`).
+*
+* This is the client-side recorder for Video Selfie and for scoped regular
+* Selfie and ID recordings. It replaces the former server-side recording path.
+*
+* Every ~0.5 s recorder blob uploads as its own chunk, concurrently with
+* recording, through {@link VideoSelfieChunkUploader} (keep-until-ack +
+* retry with backoff — see its doc for the full policy). The service stages
+* sub-5 MiB chunks and combines them server-side, so `stop()` only drains
+* the stragglers and finalizes; client memory holds un-acked chunks only.
+* No client-side encryption: video is encrypted at rest server-side
+* (S3 SSE-AES-256).
+*/
+var MultipartRecordingService = class {
+	constructor(scope = "videoselfie") {
+		this.scope = scope;
+		this.recorder = new MultipartRecordingProvider();
+		this.timer = BrowserTimerProvider.getInstance();
+		this.session = null;
+		this.uploader = null;
+		this.chunksEmitted = 0;
+		this.stopPromise = null;
+		this.abandonRequested = false;
+	}
+	get isRecording() {
+		return this.recorder.isRecording;
+	}
+	async start(stream) {
+		if (this.recorder.isRecording) return;
+		let initiated = await initiateVideoSelfieUpload(this.scope);
+		if (initiated.parts.length > 0) {
+			await abortVideoSelfieUpload(initiated).catch(() => {});
+			initiated = await initiateVideoSelfieUpload(this.scope);
+		}
+		this.session = {
+			uploadId: initiated.uploadId,
+			epoch: initiated.epoch,
+			scope: this.scope
+		};
+		this.uploader = new VideoSelfieChunkUploader(this.session);
+		this.chunksEmitted = 0;
+		this.abandonRequested = false;
+		this.recorder.startRecording(stream, ({ chunk, partNumber }) => {
+			this.chunksEmitted += 1;
+			this.uploader?.enqueue(partNumber, chunk);
+		});
+	}
+	/** Pause the current media container without finalizing its upload. */
+	pause() {
+		return this.recorder.pauseRecording?.() ?? false;
+	}
+	/** Resume the same media container after its video source has recovered. */
+	resume() {
+		return this.recorder.resumeRecording?.() ?? false;
+	}
+	stop() {
+		if (this.stopPromise) return this.stopPromise;
+		const stopPromise = this.finalizeRecording();
+		this.stopPromise = stopPromise;
+		const clearStopPromise = () => {
+			if (this.stopPromise === stopPromise) {
+				this.stopPromise = null;
+				this.abandonRequested = false;
+			}
+		};
+		stopPromise.then(clearStopPromise, clearStopPromise);
+		return stopPromise;
+	}
+	async finalizeRecording() {
+		const session = this.session;
+		const uploader = this.uploader;
+		if (!this.recorder.isRecording || !session || !uploader) return { recordingId: null };
+		try {
+			await this.recorder.stopRecording();
+			if (this.abandonRequested) {
+				this.abandonUpload(session);
+				return { recordingId: null };
+			}
+			const delivered = await uploader.drain();
+			if (this.abandonRequested || !delivered || uploader.failed || this.chunksEmitted === 0) {
+				this.abandonUpload(session);
+				return { recordingId: null };
+			}
+		} catch (error) {
+			this.abandonUpload(session);
+			throw error;
+		}
+		try {
+			await this.completeWithRetry(session);
+			this.session = null;
+			this.uploader = null;
+			return { recordingId: session.uploadId };
+		} catch {
+			this.abandonUpload(session);
+			return { recordingId: null };
+		}
+	}
+	cleanup() {
+		if (this.session) if (this.stopPromise) {
+			this.abandonRequested = true;
+			this.uploader?.dispose();
+		} else this.abandonUpload(this.session);
+		this.recorder.reset();
+	}
+	/**
+	* `complete` is idempotent server-side ("safe to repeat if the response
+	* was lost"), so transient failures — network errors, 5xx, 429 — retry a
+	* couple of times before the recording is declared failed. A 4xx (e.g.
+	* `400` naming a missing part) is permanent: after a clean drain every
+	* chunk was acked, so a reported hole cannot be filled from here.
+	*/
+	async completeWithRetry(session) {
+		for (let attempt = 1;; attempt += 1) {
+			if (this.abandonRequested) throw new Error("Video upload abandoned");
+			try {
+				await completeVideoSelfieUpload(session);
+				return;
+			} catch (error) {
+				const status = httpStatusOf(error);
+				if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || attempt >= COMPLETE_ATTEMPTS) throw error;
+				await new Promise((resolve) => {
+					this.timer.setTimeout(resolve, COMPLETE_BACKOFF_MS * attempt);
+				});
+			}
+		}
+	}
+	/**
+	* Fire-and-forget abort: the upload can no longer complete, so tell the
+	* backend to fail it immediately rather than at its expiry. Best-effort —
+	* an abort that doesn't land (including a 409 from a newer epoch having
+	* taken over) just means the server falls back to expiry or salvage.
+	*/
+	abandonUpload(session) {
+		if (this.session !== session) return;
+		this.session = null;
+		this.uploader?.dispose();
+		this.uploader = null;
+		abortVideoSelfieUpload(session).catch(() => {});
+	}
+};
+//#endregion
+export { getAdaptiveMediaRecorderOptions as n, MultipartRecordingService as t };

package/dist/{permissionGuards-KINpmKtI.esm.js → permissionGuards-uYZYFu4J.esm.js}

@@ -1,4 +1,4 @@
-import { a as isWasmMotionPrimedForModule } from "./permissionServices-UvUcOSRb.esm.js";
+import { a as isWasmMotionPrimedForModule } from "./permissionServices-Bj_fyWtv.esm.js";
 //#region src/internal/permissions/permissionGuards.ts
 function resolveStoredPermissionResult(fromEvent, fromContext) {
 	if (fromEvent === "granted" || fromEvent === "denied" || fromEvent === "prompt" || fromEvent === "refresh") return fromEvent;

package/dist/{permissionServices-UvUcOSRb.esm.js → permissionServices-Bj_fyWtv.esm.js}

@@ -1,7 +1,7 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { n as isAndroidWebView } from "./platform-BJrm5nzZ.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-DGiV77J_.esm.js";
-import { a as stopCameraStream, o as clearCameraGrantedInDocument, r as requestCameraAccess, s as isCameraGrantedInDocument } from "./camera-_2sXMXiF.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { n as isAndroidWebView } from "./platform-DkcRc9JV.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-BgTYwg9L.esm.js";
+import { c as isCameraGrantedInDocument, i as requestCameraAccess, o as stopCameraStream, s as clearCameraGrantedInDocument } from "./camera-sIa9ceW2.esm.js";
 //#region ../infra/src/media/permissions.ts
 async function queryPermission(name) {
 	try {
@@ -139,4 +139,4 @@ async function invokeRequestPermissionActor(input) {
 	return requestPermission({ requestMotion: true });
 }
 //#endregion
-export { isWasmMotionPrimedForModule as a, requestPermission as i, invokeRequestPermissionActor as n, resetWasmMotionPrimedForModule as o, primeMotionFromUserGestureIfNeeded as r, checkPermission as t };
+export { isWasmMotionPrimedForModule as a, requestPermission as i, invokeRequestPermissionActor as n, resetWasmMotionPrimedForModule as o, primeMotionFromUserGestureIfNeeded as r, queryCameraPermission as s, checkPermission as t };

package/dist/personhood.d.ts

@@ -2,12 +2,13 @@ import { A as StateMachine, i as ActorRefFrom, l as AnyStateMachine } from "./sp
 import "./StateMachine-EDpYWy0i.js";
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import "./Actor-iTq7YY48.js";
-import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { o as IncodeCanvas, t as IStorageCapability } from "./IStorageCapability-ORkQfK3F.js";
-import { t as FaceDetectionProvider } from "./FaceDetectionProvider-Mh6q3EbA.js";
-import { n as DetectionStatus, s as IWasmUtilCapability } from "./types-Hmd7U0JA.js";
+import { y as IncodeCanvas } from "./createFaceAvatar-BlcTYgJv.js";
+import { i as IStorageCapability, t as IWasmUtilCapability } from "./IWasmUtilCapability-CNWRl7jr.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
-import { n as StreamCanvasCapture, t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
+import { n as DetectionStatus } from "./types-Bnl58jUQ.js";
+import { n as DeepsightService, t as StreamCanvasCapture } from "./StreamCanvasCapture-_8gdW5Lk.js";
+import { t as FaceDetectionProvider } from "./FaceDetectionProvider-LdZ47bWy.js";
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
 //#region src/modules/personhood/types.d.ts
 /**
  * Head pose (degrees) computed per-frame from the WASM face detector.

package/dist/personhood.esm.js

@@ -1,18 +1,18 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
+import { l as BrowserStorageProvider } from "./setup-BWG-hivt.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { C as createApi$1, v as randomUUID, y as getStoredHttpConfig } from "./trueSightService---iW2KKJ.esm.js";
-import { n as eventModuleNames } from "./events-DYiyoSlx.esm.js";
-import { _ as getDeviceFingerprintInfo, g as getThumbmarkId, n as getFingerprintEnabled, p as isBrowserSimulation, v as BrowserEnvironmentProvider } from "./sessionInitializer-dlfDehHk.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-BN-Hzw82.esm.js";
+import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
+import { b as BrowserEnvironmentProvider, h as isBrowserSimulation, n as getFingerprintEnabled, v as getThumbmarkId, y as getDeviceFingerprintInfo } from "./sessionInitializer-BFk33E67.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
-import { f as stopStream, l as startDetection, s as initializeDeepsightSession, v as FaceDetectionProvider } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
+import { i as requestCameraAccess, o as stopCameraStream } from "./camera-sIa9ceW2.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-Bj_fyWtv.esm.js";
+import { i as initializeDeepsightSession, o as startDetection, s as stopStream, t as FaceDetectionProvider } from "./FaceDetectionProvider-BfhWkK90.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/personhood/personhoodServices.ts
 /**
 * Config used for the passive liveness pass. Deliberately stripped down from

package/dist/phone.esm.js

@@ -1,3 +1,3 @@
-import { t as phoneMachine } from "./phoneStateMachine-Ba0wKHyX.esm.js";
-import { t as createPhoneManager } from "./phoneManager-FsJ0W2Ei.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-CXdXufKg.esm.js";
+import { t as createPhoneManager } from "./phoneManager-IjhSv5XS.esm.js";
 export { createPhoneManager, phoneMachine };