@sekyro/web 0.1.0-rc.4 → 0.1.0-rc.6

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @sekyro/web
 
+## 0.1.0-rc.6
+
+### Minor Changes
+
+- 54b153c: `HostedSessionView.voice` + `Verification.voiceClips()` — Sekyro-hosted voice clips of the session (used by `@sekyro/react` verification mode).
+  
+  - **`HostedVoiceView` / `HostedVoiceLocale`** (new types): `{ setId, clips: { ar?, fr?, en? } }`, each locale mapping a voice key (`fcv3.*`) to an absolute clip URL on the Sekyro assets host (`assets.sekyro.ai`). A page with a Content-Security-Policy must allow that origin in `media-src`.
+  - **`HostedSessionView.voice?: HostedVoiceView | null`** — `null` when no clip set is active; absent on older APIs.
+  - **`verification.voiceClips()`** resolves the session's clips (fetching the hosted view if needed), or `null`. It never rejects: a failed bootstrap or a destroyed verification resolves `null`.
+
+## 0.1.0-rc.5
+
+### Minor Changes
+
+- a14ac15: Pre-capture building blocks: choose the camera at start, warm the face detector ahead of time, and read the camera state for a "get ready" screen.
+  
+  - **Camera at start.** `handle.start({ facing: "user" | "environment" })` (new `LivenessStartOptions`, `CameraFacing` types) picks the camera for this attempt; `retry()` keeps it and `switchCamera()` still flips it. `start()` with no options behaves as before, and `LivenessCaptureOptions.facing` remains the default. `verification.liveness()` handles pass the option through.
+  - **Detector preload.** `preloadLivenessAssets({ assetBaseUrl?, idle?, respectSaveData? })` downloads and initialises the face detector so the capture starts instantly instead of racing the cold-start deadline. It is idempotent per `assetBaseUrl`, never rejects, and resolves the settled status (`LivenessAssetsStatus`): `'ready'`; `'failed'` (call it again to retry); or `'idle'`, meaning nothing was preloaded (server-side rendering, no camera API, or Data-Saver with `respectSaveData: true`) — start normally. `idle: true` defers the load to browser idle time; a capture that needs the detector meanwhile starts it at once. The preload warms the blaze (MediaPipe) tier only, with a generous 120 s init deadline; captures without a preload keep the existing detector ladder and deadline, unchanged.
+  - **Used automatically.** Every `createLivenessCapture` / `verification.liveness()` capture with the same `assetBaseUrl` reuses the preloaded detector — no extra wiring — and destroying or retrying a capture never frees it. The preload is shared across duplicate copies of `@sekyro/web` on the page.
+  - **Status store.** `getLivenessAssetsStatus(assetBaseUrl?)` and `subscribeLivenessAssets(listener, assetBaseUrl?)` (the `useSyncExternalStore` contract: no emit on subscribe) drive a Start button's loading / retry state.
+  - **Release.** `releaseLivenessAssets(assetBaseUrl?)` frees the warmed detector (or cancels a pending idle load) when the user leaves the flow. Never call it while a capture is mounted.
+  - **Camera probes.** `queryCameraPermission()` and `subscribeCameraPermission(listener)` report `CameraPermissionState` (`'granted' | 'prompt' | 'denied' | 'unknown'`; the subscription emits the current state first, then every change). `hasMultipleCameras()` tells whether a front/back choice makes sense (phones and tablets always; desktops with two or more cameras). All are safe to call during server-side rendering and never throw.
+- 66522c3: The liveness capture now keeps the screen awake while the camera is live.
+  
+  - **Screen Wake Lock.** From `starting` through `gating` and `recording`, the capture holds a Screen Wake Lock so the phone does not dim or lock while the person positions their face. It is released on `captured`, `error` and `destroy()`, taken again on `retry()`, and re-taken automatically when the person returns to the page (browsers drop the lock when a page is hidden).
+  - **On by default, best-effort.** Browsers without the Screen Wake Lock API, or a refused request (page not visible, insecure context, blocked by Permissions-Policy), leave the capture exactly as before — nothing throws and no `error` is emitted.
+  - **Opt out:** `keepScreenAwake: false` on `createLivenessCapture({ … })` / `verification.liveness({ … })` never requests the lock.
+  - **Iframes:** if you embed the capture in an iframe, allow the permission alongside the camera — `<iframe allow="camera; screen-wake-lock">` — and do not send `Permissions-Policy: screen-wake-lock=()`. Without it the capture still works; the screen may just dim.
+  - `@sekyro/react`'s `<LivenessCapture>` gets this automatically once it runs on this `@sekyro/web` version.
+
 ## 0.1.0-rc.4
 
 ### Minor Changes

package/README.md

@@ -31,6 +31,50 @@ under `/models-v3` (or `assetBaseUrl`), and your page origin registered with Sek
 > task (Changesets + Trusted Publishing). Sekyro's own hosted page consumes it via a
 > `file:` link today. Formerly `@ibtikar/identity-web-sdk` (internal).
 
+## Preload & camera probes
+
+Warm the face detector before the user taps Start (on the step before the
+capture, or at mount), and read the camera permission for your "get ready" UI:
+
+```ts
+import { createLivenessCapture, getLivenessAssetsStatus, hasMultipleCameras,
+  preloadLivenessAssets, subscribeCameraPermission, subscribeLivenessAssets } from "@sekyro/web";
+
+void preloadLivenessAssets({ assetBaseUrl: "/models-v3", idle: true }); // never rejects
+const gateStart = (s: string) => (startBtn.disabled = s === "loading");
+gateStart(getLivenessAssetsStatus("/models-v3")); // subscribe does not emit the current status
+subscribeLivenessAssets(gateStart, "/models-v3");
+subscribeCameraPermission((p) => showCameraRow(p)); // granted|prompt|denied|unknown
+const showFacingChoice = await hasMultipleCameras();
+
+const cap = createLivenessCapture({ video, assetBaseUrl: "/models-v3" });
+await cap.start({ facing: "user" }); // reuses the warm detector automatically
+```
+
+- `preloadLivenessAssets` is idempotent per `assetBaseUrl` and resolves the settled
+  status: `'ready'`, `'failed'` (call it again to retry), or `'idle'` — nothing was
+  preloaded (SSR, no camera API, Data-Saver with `respectSaveData`); just start
+  normally. `idle: true` defers the load to browser idle time; a capture that
+  starts meanwhile begins it at once.
+- The preload warms the blaze (MediaPipe) tier with a generous deadline. Every
+  capture created afterwards with the same `assetBaseUrl` uses it without any extra
+  wiring, and destroying a capture never frees it; call
+  `releaseLivenessAssets(assetBaseUrl)` when the user leaves the flow (never while a
+  capture is mounted). Without a preload the capture loads the detector itself, as
+  before.
+- `getLivenessAssetsStatus` / `subscribeLivenessAssets` follow the
+  `useSyncExternalStore` contract (no emit on subscribe). `subscribeCameraPermission`
+  emits the current state first, then every change; `queryCameraPermission` is the
+  one-shot read. Both report `'unknown'` where the Permissions API cannot tell.
+- `start({ facing })` picks the camera for this attempt and its retries;
+  `switchCamera()` still flips it mid-capture.
+- `keepScreenAwake` (capture option, default `true`) holds a Screen Wake Lock while
+  the camera is live (`starting` / `gating` / `recording`), released on `captured`,
+  `error` and `destroy()`, re-taken on `retry()` and when the page is visible again.
+  Best-effort — unsupported or refused requests never affect the capture. In an
+  iframe, allow it: `<iframe allow="camera; screen-wake-lock">`. Pass `false` to
+  never request it.
+
 ## Entry points
 
 | Export | Contents | Public API |

package/dist/{capture-session-v3-uXJr1Wlm.d.ts → capture-session-v3-Okq0EQHG.d.ts}

@@ -429,6 +429,11 @@ interface CaptureSessionV3Options {
     now?: () => number;
 }
 type Handler<K extends keyof CaptureSessionV3Events> = (payload: CaptureSessionV3Events[K]) => void;
+/** Per-start options (the public handle's `start({ facing })`). */
+interface CaptureSessionV3StartOptions {
+    /** Camera for this attempt AND later retries; absent → keep the current one. */
+    facingMode?: "user" | "environment";
+}
 declare class CaptureSessionV3 {
     private readonly options;
     private readonly handlers;
@@ -453,7 +458,9 @@ declare class CaptureSessionV3 {
     get state(): CaptureState;
     on<K extends keyof CaptureSessionV3Events>(event: K, handler: Handler<K>): () => void;
     private emit;
-    start(): Promise<void>;
+    start(options?: CaptureSessionV3StartOptions): Promise<void>;
+    /** The camera the current/next attempt requests (start option, switchCamera toggles). */
+    get facingMode(): "user" | "environment";
     /** Full reset + camera restart — the documented recovery path (v1 parity). */
     retry(): void;
     switchCamera(): void;
@@ -484,4 +491,4 @@ declare class CaptureSessionV3 {
     private now;
 }
 
-export { type V3TelemetryEvent as A, V3_GATE_DEFAULTS as B, type CameraErrorKind as C, DEFAULT_CLIP_MIME as D, type EscalationClipArtifact as E, FaceGateV3 as F, type GateChecks as G, VIDEO_BPS as H, buildLivenessV2FormData as I, cameraPreflight as J, KEYFRAME_CANDIDATES as K, classifyDevice as L, MAX_CLIP_BYTES as M, extForMime as N, isClipTooLarge as O, isMediaRecorderSupported as P, mapGetUserMediaError as Q, pickMimeType as R, STOP_GRACE_MS as S, TIMESLICE_MS as T, probeDevice as U, type V3ChecksPayload as V, CLIP_MS as a, type CaptureArtifacts as b, type CaptureErrorKind as c, type CaptureSessionEvents as d, CaptureSessionV3 as e, type CaptureSessionV3Events as f, type CaptureSessionV3Options as g, type CaptureState as h, type CaptureTiming as i, ClipError as j, type ClipErrorKind as k, ClipRecorder as l, type ClipResult as m, DEVICE_PROFILES as n, type DeviceClass as o, type DeviceProbe as p, type DeviceProfile as q, DeviceProfiler as r, type EscalationHook as s, KEYFRAME_WINDOW_MS as t, MIME_CANDIDATES as u, type V3GateFactor as v, type V3GateQuality as w, type V3GateThresholds as x, type V3GateTick as y, type V3GateTickInput as z };
+export { type V3GateTickInput as A, type V3TelemetryEvent as B, type CameraErrorKind as C, DEFAULT_CLIP_MIME as D, type EscalationClipArtifact as E, FaceGateV3 as F, type GateChecks as G, V3_GATE_DEFAULTS as H, VIDEO_BPS as I, buildLivenessV2FormData as J, KEYFRAME_CANDIDATES as K, cameraPreflight as L, MAX_CLIP_BYTES as M, classifyDevice as N, extForMime as O, isClipTooLarge as P, isMediaRecorderSupported as Q, mapGetUserMediaError as R, STOP_GRACE_MS as S, TIMESLICE_MS as T, pickMimeType as U, type V3ChecksPayload as V, probeDevice as W, CLIP_MS as a, type CaptureArtifacts as b, type CaptureErrorKind as c, type CaptureSessionEvents as d, CaptureSessionV3 as e, type CaptureSessionV3Events as f, type CaptureSessionV3Options as g, type CaptureSessionV3StartOptions as h, type CaptureState as i, type CaptureTiming as j, ClipError as k, type ClipErrorKind as l, ClipRecorder as m, type ClipResult as n, DEVICE_PROFILES as o, type DeviceClass as p, type DeviceProbe as q, type DeviceProfile as r, DeviceProfiler as s, type EscalationHook as t, KEYFRAME_WINDOW_MS as u, MIME_CANDIDATES as v, type V3GateFactor as w, type V3GateQuality as x, type V3GateThresholds as y, type V3GateTick as z };

package/dist/{capture-session-v3-DEInCOUg.d.cts → capture-session-v3-UQU_WjO2.d.cts}

@@ -429,6 +429,11 @@ interface CaptureSessionV3Options {
     now?: () => number;
 }
 type Handler<K extends keyof CaptureSessionV3Events> = (payload: CaptureSessionV3Events[K]) => void;
+/** Per-start options (the public handle's `start({ facing })`). */
+interface CaptureSessionV3StartOptions {
+    /** Camera for this attempt AND later retries; absent → keep the current one. */
+    facingMode?: "user" | "environment";
+}
 declare class CaptureSessionV3 {
     private readonly options;
     private readonly handlers;
@@ -453,7 +458,9 @@ declare class CaptureSessionV3 {
     get state(): CaptureState;
     on<K extends keyof CaptureSessionV3Events>(event: K, handler: Handler<K>): () => void;
     private emit;
-    start(): Promise<void>;
+    start(options?: CaptureSessionV3StartOptions): Promise<void>;
+    /** The camera the current/next attempt requests (start option, switchCamera toggles). */
+    get facingMode(): "user" | "environment";
     /** Full reset + camera restart — the documented recovery path (v1 parity). */
     retry(): void;
     switchCamera(): void;
@@ -484,4 +491,4 @@ declare class CaptureSessionV3 {
     private now;
 }
 
-export { type V3TelemetryEvent as A, V3_GATE_DEFAULTS as B, type CameraErrorKind as C, DEFAULT_CLIP_MIME as D, type EscalationClipArtifact as E, FaceGateV3 as F, type GateChecks as G, VIDEO_BPS as H, buildLivenessV2FormData as I, cameraPreflight as J, KEYFRAME_CANDIDATES as K, classifyDevice as L, MAX_CLIP_BYTES as M, extForMime as N, isClipTooLarge as O, isMediaRecorderSupported as P, mapGetUserMediaError as Q, pickMimeType as R, STOP_GRACE_MS as S, TIMESLICE_MS as T, probeDevice as U, type V3ChecksPayload as V, CLIP_MS as a, type CaptureArtifacts as b, type CaptureErrorKind as c, type CaptureSessionEvents as d, CaptureSessionV3 as e, type CaptureSessionV3Events as f, type CaptureSessionV3Options as g, type CaptureState as h, type CaptureTiming as i, ClipError as j, type ClipErrorKind as k, ClipRecorder as l, type ClipResult as m, DEVICE_PROFILES as n, type DeviceClass as o, type DeviceProbe as p, type DeviceProfile as q, DeviceProfiler as r, type EscalationHook as s, KEYFRAME_WINDOW_MS as t, MIME_CANDIDATES as u, type V3GateFactor as v, type V3GateQuality as w, type V3GateThresholds as x, type V3GateTick as y, type V3GateTickInput as z };
+export { type V3GateTickInput as A, type V3TelemetryEvent as B, type CameraErrorKind as C, DEFAULT_CLIP_MIME as D, type EscalationClipArtifact as E, FaceGateV3 as F, type GateChecks as G, V3_GATE_DEFAULTS as H, VIDEO_BPS as I, buildLivenessV2FormData as J, KEYFRAME_CANDIDATES as K, cameraPreflight as L, MAX_CLIP_BYTES as M, classifyDevice as N, extForMime as O, isClipTooLarge as P, isMediaRecorderSupported as Q, mapGetUserMediaError as R, STOP_GRACE_MS as S, TIMESLICE_MS as T, pickMimeType as U, type V3ChecksPayload as V, probeDevice as W, CLIP_MS as a, type CaptureArtifacts as b, type CaptureErrorKind as c, type CaptureSessionEvents as d, CaptureSessionV3 as e, type CaptureSessionV3Events as f, type CaptureSessionV3Options as g, type CaptureSessionV3StartOptions as h, type CaptureState as i, type CaptureTiming as j, ClipError as k, type ClipErrorKind as l, ClipRecorder as m, type ClipResult as n, DEVICE_PROFILES as o, type DeviceClass as p, type DeviceProbe as q, type DeviceProfile as r, DeviceProfiler as s, type EscalationHook as t, KEYFRAME_WINDOW_MS as u, MIME_CANDIDATES as v, type V3GateFactor as w, type V3GateQuality as x, type V3GateThresholds as y, type V3GateTick as z };

package/dist/{chunk-TBANUT3X.js → chunk-R3SJQHYU.js}

@@ -2,12 +2,191 @@ import {
   CaptureSessionV3,
   detectIsMobile,
   isMediaRecorderSupported
-} from "./chunk-EWRNPKTR.js";
+} from "./chunk-TG5IE552.js";
 import {
   HostedApiError,
   HostedClient,
   stripMimeParams
 } from "./chunk-YVFF4Q4G.js";
+import {
+  DEFAULT_V3_ASSET_BASE_URL,
+  createDetector
+} from "./chunk-NWF46H7K.js";
+
+// src/capture/preload.ts
+var PRELOAD_BLAZE_INIT_TIMEOUT_MS = 12e4;
+var PRELOAD_BUDGET_MS = 13e4;
+var IDLE_TIMEOUT_MS = 3e3;
+var IDLE_FALLBACK_MS = 1200;
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@sekyro/web.preload.v1");
+function registry() {
+  const host = globalThis;
+  host[REGISTRY_KEY] ?? (host[REGISTRY_KEY] = /* @__PURE__ */ new Map());
+  return host[REGISTRY_KEY];
+}
+function normalizeBase(assetBaseUrl) {
+  const base = (assetBaseUrl ?? DEFAULT_V3_ASSET_BASE_URL).replace(/\/+$/, "");
+  return base === "" ? "/" : base;
+}
+function entryFor(base) {
+  const map = registry();
+  let entry = map.get(base);
+  if (entry === void 0) {
+    entry = { status: "idle", promise: null, scheduled: null, detectorPromise: null, detector: null, listeners: /* @__PURE__ */ new Set() };
+    map.set(base, entry);
+  }
+  return entry;
+}
+function setStatus(entry, next) {
+  if (entry.status === next) return;
+  entry.status = next;
+  for (const listener of [...entry.listeners]) listener(next);
+}
+var defaultLoader = (base) => createDetector({ preferred: ["blaze"], v3AssetBaseUrl: base, blazeInitTimeoutMs: PRELOAD_BLAZE_INIT_TIMEOUT_MS });
+var loader = defaultLoader;
+function setPreloadLoaderForTests(next) {
+  loader = next ?? defaultLoader;
+}
+function resetLivenessAssetsForTests() {
+  for (const entry of registry().values()) entry.detector?.destroy();
+  registry().clear();
+  loader = defaultLoader;
+}
+function canCapture() {
+  return typeof window !== "undefined" && typeof navigator !== "undefined" && typeof navigator.mediaDevices?.getUserMedia === "function";
+}
+function saveDataOn() {
+  return navigator.connection?.saveData === true;
+}
+function scheduleIdle(run) {
+  const w = window;
+  if (typeof w.requestIdleCallback === "function") {
+    const handle = w.requestIdleCallback(run, { timeout: IDLE_TIMEOUT_MS });
+    return () => w.cancelIdleCallback?.(handle);
+  }
+  const timer = setTimeout(run, IDLE_FALLBACK_MS);
+  return () => clearTimeout(timer);
+}
+function schedule(entry, base) {
+  let resolve;
+  const promise = new Promise((res) => {
+    resolve = res;
+  });
+  let done = false;
+  let cancel = () => void 0;
+  const scheduled = {
+    promise,
+    settle: (outcome) => {
+      if (done) return;
+      done = true;
+      cancel();
+      if (entry.scheduled === scheduled) entry.scheduled = null;
+      resolve(outcome);
+    }
+  };
+  entry.scheduled = scheduled;
+  cancel = scheduleIdle(() => {
+    if (done) return;
+    scheduled.settle(begin(entry, base));
+  });
+  return promise;
+}
+function begin(entry, base) {
+  if ((entry.status === "loading" || entry.status === "ready") && entry.promise !== null) return entry.promise;
+  setStatus(entry, "loading");
+  const detectorPromise = new Promise((resolve) => resolve(loader(base)));
+  entry.detectorPromise = detectorPromise;
+  let timer;
+  const budget = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      detectorPromise.then((late) => late.destroy(), () => void 0);
+      reject(new Error(`detector preload exceeded ${PRELOAD_BUDGET_MS} ms`));
+    }, PRELOAD_BUDGET_MS);
+  });
+  const settled = Promise.race([detectorPromise, budget]).then(
+    (detector) => {
+      if (entry.detectorPromise !== detectorPromise) {
+        detector.destroy();
+        return entry.status;
+      }
+      entry.detector = detector;
+      setStatus(entry, "ready");
+      return "ready";
+    },
+    (err) => {
+      if (entry.detectorPromise === detectorPromise) {
+        entry.detectorPromise = null;
+        entry.detector = null;
+        setStatus(entry, "failed");
+        console.warn("[@sekyro/web] face-detector preload failed:", err);
+      }
+      return entry.status;
+    }
+  );
+  const promise = settled.finally(() => clearTimeout(timer));
+  entry.promise = promise;
+  entry.scheduled?.settle(promise);
+  return promise;
+}
+function preloadLivenessAssets(options = {}) {
+  if (!canCapture()) return Promise.resolve("idle");
+  const base = normalizeBase(options.assetBaseUrl);
+  const entry = entryFor(base);
+  if (options.respectSaveData === true && saveDataOn()) return Promise.resolve(entry.status);
+  if ((entry.status === "loading" || entry.status === "ready") && entry.promise !== null) return entry.promise;
+  if (options.idle === true) return entry.scheduled?.promise ?? schedule(entry, base);
+  return begin(entry, base);
+}
+function getLivenessAssetsStatus(assetBaseUrl) {
+  return registry().get(normalizeBase(assetBaseUrl))?.status ?? "idle";
+}
+function subscribeLivenessAssets(listener, assetBaseUrl) {
+  const entry = entryFor(normalizeBase(assetBaseUrl));
+  entry.listeners.add(listener);
+  return () => {
+    entry.listeners.delete(listener);
+  };
+}
+function releaseLivenessAssets(assetBaseUrl) {
+  const entry = registry().get(normalizeBase(assetBaseUrl));
+  if (entry === void 0) return;
+  entry.scheduled?.settle("idle");
+  entry.detector?.destroy();
+  entry.detector = null;
+  entry.detectorPromise = null;
+  entry.promise = null;
+  setStatus(entry, "idle");
+}
+function nonOwningView(shared) {
+  return {
+    get tier() {
+      return shared.tier;
+    },
+    get fallbackReason() {
+      return shared.fallbackReason;
+    },
+    detect: (...args) => shared.detect(...args),
+    destroy: () => {
+    }
+  };
+}
+function preloadedDetectorFactory(assetBaseUrl) {
+  const base = normalizeBase(assetBaseUrl);
+  const entry = registry().get(base);
+  if (entry === void 0 || entry.detector === null && entry.detectorPromise === null && entry.scheduled === null) {
+    return void 0;
+  }
+  return async () => {
+    if (entry.scheduled !== null) void begin(entry, base);
+    let waitingOn = entry.promise;
+    while (entry.detector === null && waitingOn !== null) {
+      await waitingOn;
+      if (entry.promise === waitingOn) break;
+      waitingOn = entry.promise;
+    }
+    return entry.detector !== null ? nonOwningView(entry.detector) : createDetector({ v3AssetBaseUrl: base });
+  };
+}
 
 // src/verification/emitter.ts
 function createEmitter() {
@@ -38,6 +217,83 @@ function createEmitter() {
   };
 }
 
+// src/capture/wake-lock.ts
+function wakeLockApi() {
+  if (typeof navigator === "undefined" || !("wakeLock" in navigator)) return null;
+  const api = navigator.wakeLock;
+  return typeof api?.request === "function" ? api : null;
+}
+function isVisible() {
+  return typeof document === "undefined" || document.visibilityState === "visible";
+}
+function releaseQuietly(sentinel) {
+  try {
+    void sentinel.release().catch(() => void 0);
+  } catch {
+  }
+}
+function createScreenWakeLock(options = {}) {
+  if (options.enabled === false) return { setActive: () => void 0 };
+  let wanted = false;
+  let sentinel = null;
+  let inFlight = false;
+  let listening = false;
+  const acquire = () => {
+    if (!wanted || inFlight || sentinel !== null && !sentinel.released) return;
+    const api = wakeLockApi();
+    if (api === null || !isVisible()) return;
+    let request;
+    try {
+      request = api.request("screen");
+    } catch {
+      return;
+    }
+    inFlight = true;
+    request.then(
+      (granted) => {
+        inFlight = false;
+        if (!wanted) {
+          releaseQuietly(granted);
+          return;
+        }
+        sentinel = granted;
+        granted.addEventListener?.("release", () => {
+          if (sentinel === granted) sentinel = null;
+        });
+      },
+      () => {
+        inFlight = false;
+      }
+    );
+  };
+  const onVisibilityChange = () => {
+    if (isVisible()) acquire();
+  };
+  const listen = (on) => {
+    if (typeof document === "undefined" || on === listening) return;
+    listening = on;
+    if (on) document.addEventListener("visibilitychange", onVisibilityChange);
+    else document.removeEventListener("visibilitychange", onVisibilityChange);
+  };
+  return {
+    setActive: (active) => {
+      wanted = active;
+      if (active) {
+        if (wakeLockApi() === null) return;
+        listen(true);
+        acquire();
+        return;
+      }
+      listen(false);
+      if (sentinel !== null) {
+        const held = sentinel;
+        sentinel = null;
+        releaseQuietly(held);
+      }
+    }
+  };
+}
+
 // src/capture/create-liveness-capture.ts
 function mapGuidanceHint(key) {
   switch (key) {
@@ -101,12 +357,22 @@ function createLivenessCaptureInternal(options, internals = {}) {
   const now = internals.now ?? (() => performance.now());
   const emitter = createEmitter();
   const degraded = !isMediaRecorderSupported();
+  const hostSeams = internals.engineOptions;
+  const preloadAware = hostSeams?.createDetector === void 0 && hostSeams?.createWorker === void 0 ? {
+    createDetector: () => {
+      const warmed = preloadedDetectorFactory(options.assetBaseUrl);
+      return warmed !== void 0 ? warmed() : createDetector(
+        options.assetBaseUrl !== void 0 ? { v3AssetBaseUrl: options.assetBaseUrl } : {}
+      );
+    }
+  } : {};
   const engineOptions = {
     video: options.video,
     mode: degraded ? "photo" : "clip",
     ...options.facing !== void 0 ? { facingMode: options.facing } : {},
     ...options.assetBaseUrl !== void 0 ? { v3AssetBaseUrl: options.assetBaseUrl } : {},
-    ...internals.engineOptions ?? {}
+    ...internals.engineOptions ?? {},
+    ...preloadAware
   };
   const engine = internals.createEngine?.(engineOptions) ?? new CaptureSessionV3(engineOptions);
   let state = "idle";
@@ -124,8 +390,10 @@ function createLivenessCaptureInternal(options, internals = {}) {
       frameHeight = options.video.videoHeight;
     }
   };
+  const wakeLock = createScreenWakeLock({ enabled: options.keepScreenAwake !== false });
   const setState = (next) => {
     state = next;
+    wakeLock.setActive(next === "starting" || next === "gating" || next === "recording");
     emitter.emit("state", next);
   };
   const emitGate = () => emitter.emit("gate", { progress, hint, faceDetected });
@@ -199,11 +467,12 @@ function createLivenessCaptureInternal(options, internals = {}) {
       return state;
     },
     on: (event, handler) => emitter.on(event, handler),
-    start: () => engine.start(),
+    start: (startOptions) => engine.start(startOptions?.facing !== void 0 ? { facingMode: startOptions.facing } : {}),
     retry: () => engine.retry(),
     switchCamera: () => engine.switchCamera(),
     destroy: () => {
       for (const unsubscribe of unsubscribes) unsubscribe();
+      wakeLock.setActive(false);
       engine.destroy();
       emitter.clear();
     }
@@ -671,7 +940,7 @@ function createVerificationInternal(options, internals) {
     }
     emitter.emit("result", result);
   };
-  let registry = null;
+  let registry2 = null;
   let registryFailed = false;
   let registryUnbound = false;
   const submitRegistry = () => runSubmission(
@@ -706,8 +975,8 @@ function createVerificationInternal(options, internals) {
     if (view !== null && isTerminalView(view)) emitResult(mapSessionResult(view, { autoRetry }));
   };
   const startRegistry = () => {
-    registry ?? (registry = runRegistry());
-    return registry;
+    registry2 ?? (registry2 = runRegistry());
+    return registry2;
   };
   const getAttestation = async () => {
     const current = await ensureView();
@@ -822,7 +1091,7 @@ function createVerificationInternal(options, internals) {
         return inner.state;
       },
       on: (event, handler) => inner.on(event, handler),
-      start: () => inner.start(),
+      start: (startOptions) => inner.start(startOptions),
       retry: () => inner.retry(),
       switchCamera: () => inner.switchCamera(),
       destroy: () => {
@@ -836,6 +1105,16 @@ function createVerificationInternal(options, internals) {
     consent: () => ensureConsent(),
     startRegistry,
     liveness,
+    voiceClips: async () => {
+      if (destroyed) return null;
+      try {
+        const current = await ensureView();
+        if (destroyed) return null;
+        return current.voice ?? null;
+      } catch {
+        return null;
+      }
+    },
     on: (event, handler) => emitter.on(event, handler),
     destroy: () => {
       destroyed = true;
@@ -851,6 +1130,15 @@ function createVerificationInternal(options, internals) {
 }
 
 export {
+  PRELOAD_BLAZE_INIT_TIMEOUT_MS,
+  PRELOAD_BUDGET_MS,
+  setPreloadLoaderForTests,
+  resetLivenessAssetsForTests,
+  preloadLivenessAssets,
+  getLivenessAssetsStatus,
+  subscribeLivenessAssets,
+  releaseLivenessAssets,
+  preloadedDetectorFactory,
   mapGuidanceHint,
   mapEngineState,
   mapErrorKind,
@@ -882,4 +1170,4 @@ export {
   createVerification,
   createVerificationInternal
 };
-//# sourceMappingURL=chunk-TBANUT3X.js.map
+//# sourceMappingURL=chunk-R3SJQHYU.js.map