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

package/dist/index.cjs

@@ -36,8 +36,15 @@ __export(src_exports, {
   SEKYRO_EVENTS: () => SEKYRO_EVENTS,
   createLivenessCapture: () => createLivenessCapture,
   createVerification: () => createVerification,
+  getLivenessAssetsStatus: () => getLivenessAssetsStatus,
+  hasMultipleCameras: () => hasMultipleCameras,
   isKnownCode: () => isKnownCode,
-  openHosted: () => openHosted
+  openHosted: () => openHosted,
+  preloadLivenessAssets: () => preloadLivenessAssets,
+  queryCameraPermission: () => queryCameraPermission,
+  releaseLivenessAssets: () => releaseLivenessAssets,
+  subscribeCameraPermission: () => subscribeCameraPermission,
+  subscribeLivenessAssets: () => subscribeLivenessAssets
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -1102,10 +1109,15 @@ var CaptureSessionV3 = class {
       handler(payload);
     }
   }
-  async start() {
+  async start(options = {}) {
+    if (options.facingMode !== void 0) this.facing = options.facingMode;
     this.attempt += 1;
     await this.run(this.attempt);
   }
+  /** The camera the current/next attempt requests (start option, switchCamera toggles). */
+  get facingMode() {
+    return this.facing;
+  }
   /** Full reset + camera restart — the documented recovery path (v1 parity). */
   retry() {
     this.teardownAttempt();
@@ -1513,6 +1525,250 @@ function createEmitter() {
   };
 }
 
+// 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 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/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) {
@@ -1576,12 +1832,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";
@@ -1599,8 +1865,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 });
@@ -1674,11 +1942,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();
     }
@@ -1694,6 +1963,52 @@ function createLivenessCapture(options) {
   return createLivenessCaptureInternal(options).handle;
 }
 
+// src/capture/camera-probe.ts
+async function permissionStatus() {
+  try {
+    if (typeof navigator === "undefined" || typeof navigator.permissions?.query !== "function") return null;
+    return await navigator.permissions.query({ name: "camera" });
+  } catch {
+    return null;
+  }
+}
+function asState(state) {
+  return state === "granted" || state === "prompt" || state === "denied" ? state : "unknown";
+}
+async function queryCameraPermission() {
+  const status = await permissionStatus();
+  return status === null ? "unknown" : asState(status.state);
+}
+function subscribeCameraPermission(listener) {
+  let stopped = false;
+  let status = null;
+  const onChange = () => {
+    if (!stopped && status !== null) listener(asState(status.state));
+  };
+  void permissionStatus().then((resolved) => {
+    if (stopped) return;
+    status = resolved;
+    listener(resolved === null ? "unknown" : asState(resolved.state));
+    resolved?.addEventListener?.("change", onChange);
+  });
+  return () => {
+    stopped = true;
+    status?.removeEventListener?.("change", onChange);
+  };
+}
+async function hasMultipleCameras() {
+  if (typeof navigator === "undefined") return false;
+  const ua = String(navigator.userAgent ?? "");
+  if (/Android|iPhone|iPad|iPod/i.test(ua)) return true;
+  if (/Macintosh/.test(ua) && (navigator.maxTouchPoints ?? 0) > 1) return true;
+  try {
+    const devices = await navigator.mediaDevices?.enumerateDevices?.() ?? [];
+    return devices.filter((device) => device.kind === "videoinput").length >= 2;
+  } catch {
+    return false;
+  }
+}
+
 // src/client/errors.ts
 var KNOWN_CODES = [
   // auth / addressing (session-token.guard, controllers' own-session guards)
@@ -2462,7 +2777,7 @@ function createVerificationInternal(options, internals) {
     }
     emitter.emit("result", result);
   };
-  let registry = null;
+  let registry2 = null;
   let registryFailed = false;
   let registryUnbound = false;
   const submitRegistry = () => runSubmission(
@@ -2497,8 +2812,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();
@@ -2613,7 +2928,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: () => {
@@ -2627,6 +2942,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;
@@ -2692,7 +3017,14 @@ function openHosted(hostedUrl, opts) {
   SEKYRO_EVENTS,
   createLivenessCapture,
   createVerification,
+  getLivenessAssetsStatus,
+  hasMultipleCameras,
   isKnownCode,
-  openHosted
+  openHosted,
+  preloadLivenessAssets,
+  queryCameraPermission,
+  releaseLivenessAssets,
+  subscribeCameraPermission,
+  subscribeLivenessAssets
 });
 //# sourceMappingURL=index.cjs.map