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

package/dist/chunk-R3SJQHYU.js

@@ -1,1173 +0,0 @@
-import {
-  CaptureSessionV3,
-  detectIsMobile,
-  isMediaRecorderSupported
-} 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() {
-  const handlers = /* @__PURE__ */ new Map();
-  return {
-    on(event, handler) {
-      let set = handlers.get(event);
-      if (set === void 0) {
-        set = /* @__PURE__ */ new Set();
-        handlers.set(event, set);
-      }
-      const h = handler;
-      set.add(h);
-      return () => {
-        set?.delete(h);
-      };
-    },
-    emit(event, payload) {
-      const set = handlers.get(event);
-      if (set === void 0) return;
-      for (const handler of [...set]) {
-        handler(payload);
-      }
-    },
-    clear() {
-      handlers.clear();
-    }
-  };
-}
-
-// 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) {
-    case "fcv3.no_face":
-    case "fcv3.center_face":
-    case "fcv3.straighten":
-      return "center";
-    case "fcv3.come_closer":
-      return "closer";
-    case "fcv3.move_back":
-      return "farther";
-    case "fcv3.more_light":
-    case "fcv3.too_bright":
-      return "light";
-    case "fcv3.hold_still":
-    case "fcv3.steady_camera":
-      return "still";
-    default:
-      return null;
-  }
-}
-function mapEngineState(state) {
-  switch (state) {
-    case "preflight":
-    case "acquiring":
-      return "starting";
-    case "positioning":
-      return "gating";
-    case "idle":
-    case "recording":
-    case "captured":
-    case "error":
-      return state;
-    default: {
-      const unhandled = state;
-      throw new Error(`mapEngineState: unhandled state ${unhandled}`);
-    }
-  }
-}
-function mapErrorKind(kind) {
-  switch (kind) {
-    case "permission":
-    case "notfound":
-    case "inuse":
-    case "insecure":
-    case "unsupported":
-      return kind;
-    case "overconstrained":
-    case "generic":
-    case "models":
-    case "cliptoolarge":
-    case "recorder":
-      return "generic";
-    default: {
-      const unhandled = kind;
-      throw new Error(`mapErrorKind: unhandled kind ${unhandled}`);
-    }
-  }
-}
-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 ?? {},
-    ...preloadAware
-  };
-  const engine = internals.createEngine?.(engineOptions) ?? new CaptureSessionV3(engineOptions);
-  let state = "idle";
-  let hint = null;
-  let progress = 0;
-  let faceDetected = false;
-  let animations = "full";
-  let recordingStartedAt = null;
-  let frozenAt = null;
-  let frameWidth = 0;
-  let frameHeight = 0;
-  const latchFrameSize = () => {
-    if (options.video.videoWidth > 0 && options.video.videoHeight > 0) {
-      frameWidth = options.video.videoWidth;
-      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 });
-  const syncProfile = () => {
-    const next = engine.animations ?? "full";
-    if (next === animations) return;
-    animations = next;
-    emitter.emit("profile", { animations });
-  };
-  const unsubscribes = [
-    engine.on("statechange", ({ state: engineState }) => {
-      const next = mapEngineState(engineState);
-      if (next === "starting" && state !== "starting") {
-        hint = null;
-        progress = 0;
-        faceDetected = false;
-        recordingStartedAt = null;
-        frozenAt = null;
-        frameWidth = 0;
-        frameHeight = 0;
-      }
-      setState(next);
-      syncProfile();
-      if (next === "recording") {
-        latchFrameSize();
-        recordingStartedAt = now();
-        hint = "hold";
-        progress = 1;
-        emitGate();
-      }
-    }),
-    engine.on("checks", (payload) => {
-      latchFrameSize();
-      progress = payload.progress;
-      faceDetected = payload.factors.presence > 0;
-      emitGate();
-      syncProfile();
-    }),
-    engine.on("guidance", ({ key }) => {
-      hint = mapGuidanceHint(key);
-      emitGate();
-    }),
-    engine.on("frozen", ({ previewDataUrl }) => {
-      frozenAt = now();
-      emitter.emit("frozen", { previewDataUrl });
-    }),
-    engine.on("artifacts", (artifacts) => {
-      const clipMs = recordingStartedAt !== null && frozenAt !== null ? Math.max(0, Math.round(frozenAt - recordingStartedAt)) : void 0;
-      emitter.emit("captured", {
-        keyframe: artifacts.keyframe,
-        ...artifacts.clip !== void 0 ? { clip: artifacts.clip } : {},
-        ...artifacts.clipMimeType !== void 0 ? { clipMime: artifacts.clipMimeType } : {},
-        width: options.video.videoWidth || frameWidth,
-        height: options.video.videoHeight || frameHeight,
-        ...clipMs !== void 0 ? { clipMs } : {},
-        captureChannel: detectIsMobile() ? "mobile" : "desktop",
-        ...degraded ? { degraded: "NO_RECORDER" } : {},
-        engine: "v3",
-        // Face-capture timing: the engine's marks, forwarded flat (absent → absent).
-        ...artifacts.timing?.cameraReadyMs !== void 0 ? { cameraReadyMs: artifacts.timing.cameraReadyMs } : {},
-        ...artifacts.timing?.faceAcquireMs !== void 0 ? { faceAcquireMs: artifacts.timing.faceAcquireMs } : {},
-        ...artifacts.timing?.captureMs !== void 0 ? { captureMs: artifacts.timing.captureMs } : {}
-      });
-    }),
-    engine.on("error", ({ kind, retryable }) => {
-      emitter.emit("error", { kind: mapErrorKind(kind), retryable });
-    })
-  ];
-  const handle = {
-    get state() {
-      return state;
-    },
-    on: (event, handler) => emitter.on(event, handler),
-    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();
-    }
-  };
-  return {
-    handle,
-    setFlowState: (next) => {
-      if (state !== next) setState(next);
-    }
-  };
-}
-function createLivenessCapture(options) {
-  return createLivenessCaptureInternal(options).handle;
-}
-
-// src/verification/result.ts
-var RETRYABLE_REASONS = /* @__PURE__ */ new Set([
-  "no_face",
-  "media_unreadable",
-  "clip_too_short",
-  "no_face_source",
-  "side_missing",
-  "unreadable",
-  "registry_unavailable",
-  "otp_mismatch",
-  "otp_expired",
-  "otp_send_failed"
-]);
-var BIOMETRIC_CHECKS = /* @__PURE__ */ new Set(["liveness", "face_match"]);
-function isExecutable(step) {
-  return step !== void 0 && (step.state === "pending" || step.state === "input_required");
-}
-function isTerminalView(view) {
-  return view.status !== "created" && view.status !== "in_progress";
-}
-function frontierStep(view) {
-  return view.steps.find((step) => isExecutable(step));
-}
-function stepOf(view, checkType) {
-  return view.steps.find((step) => step.checkType === checkType);
-}
-function mergeSessionView(prev, next, submitted) {
-  const byType = new Map(prev.steps.map((step) => [step.checkType, step]));
-  const steps = next.steps.map((step) => {
-    const before = byType.get(step.checkType);
-    const attemptsBefore = before?.attemptsRemaining ?? 0;
-    const merged = {
-      ...before ?? {},
-      checkType: step.checkType,
-      state: step.state,
-      attemptsRemaining: step.checkType === submitted ? Math.max(0, attemptsBefore - 1) : attemptsBefore
-    };
-    if (step.reason !== void 0) merged.reason = step.reason;
-    else delete merged.reason;
-    return merged;
-  });
-  return { ...prev, status: next.status, outcome: next.outcome, steps, expiresAt: next.expiresAt };
-}
-function unavailable(sessionId, reason) {
-  return reason === void 0 ? { sessionId, status: "unavailable" } : { sessionId, status: "unavailable", reason };
-}
-function withReason(sessionId, status, reason) {
-  return reason === void 0 ? { sessionId, status } : { sessionId, status, reason };
-}
-function mapSessionResult(view, opts) {
-  const { sessionId } = view;
-  switch (view.status) {
-    case "completed":
-      if (view.outcome === "approved") return { sessionId, status: "approved" };
-      if (view.outcome === "review") return withReason(sessionId, "review", reasonIn(view, "review"));
-      return withReason(sessionId, "rejected", reasonIn(view, "failed"));
-    case "failed":
-      return withReason(sessionId, "rejected", reasonIn(view, "failed"));
-    case "review_pending":
-      return withReason(sessionId, "review", reasonIn(view, "review"));
-    case "expired":
-      return unavailable(sessionId);
-    case "created":
-    case "in_progress":
-      break;
-    default: {
-      const unhandled = view.status;
-      throw new Error(`mapSessionResult: unhandled status ${unhandled}`);
-    }
-  }
-  const parked = view.steps.find(
-    (step) => BIOMETRIC_CHECKS.has(step.checkType) && step.state === "input_required" && step.reason !== void 0
-  );
-  if (parked?.reason !== void 0) {
-    const canRetry = opts.autoRetry && RETRYABLE_REASONS.has(parked.reason) && parked.attemptsRemaining > 0;
-    return {
-      sessionId,
-      status: canRetry ? "retry" : "rejected",
-      reason: parked.reason,
-      attemptsRemaining: parked.attemptsRemaining
-    };
-  }
-  if (frontierStep(view) === void 0 && view.steps.some((step) => step.state === "review")) {
-    return withReason(sessionId, "review", reasonIn(view, "review"));
-  }
-  return unavailable(sessionId);
-}
-function reasonIn(view, state) {
-  return view.steps.find((step) => step.state === state && step.reason !== void 0)?.reason;
-}
-
-// src/verification/liveness-flow.ts
-var CLIP_MIME_ALLOWLIST = ["video/webm", "video/mp4"];
-var KEYFRAME_MIME = "image/jpeg";
-var TRANSPORT_REPLAY_ATTEMPTS = 2;
-var TRANSPORT_REPLAY_DELAY_MS = 1e3;
-var MAX_RETRY_AFTER_MS = 1e4;
-var RESYNC_REENTRY_MAX = 3;
-var TRANSPORT_CODES = /* @__PURE__ */ new Set([
-  "network_error",
-  "timeout",
-  "upload_failed",
-  "unknown_error",
-  "rate_limit_exceeded"
-]);
-var RESYNC_CODES = /* @__PURE__ */ new Set([
-  "session_not_active",
-  "check_not_found",
-  "check_already_finalized",
-  "check_out_of_order"
-]);
-var AttestationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AttestationError";
-  }
-};
-async function runSubmission(rt, executor, hooks = {}) {
-  let key = rt.uuid();
-  let consentRecovered = false;
-  let attestationRetried = false;
-  let transportReplays = 0;
-  for (; ; ) {
-    try {
-      return await executor(rt.client, key);
-    } catch (err) {
-      if (err instanceof AttestationError) {
-        if (attestationRetried) throw err;
-        attestationRetried = true;
-        hooks.onAttestationInvalid?.();
-        key = rt.uuid();
-        continue;
-      }
-      if (!(err instanceof HostedApiError)) throw err;
-      if (err.code === "consent_required" && !consentRecovered) {
-        consentRecovered = true;
-        await rt.ensureConsent({ force: true });
-        key = rt.uuid();
-        continue;
-      }
-      if (err.code === "attestation_invalid" && !attestationRetried) {
-        attestationRetried = true;
-        hooks.onAttestationInvalid?.();
-        key = rt.uuid();
-        continue;
-      }
-      if (TRANSPORT_CODES.has(err.code) && transportReplays < TRANSPORT_REPLAY_ATTEMPTS) {
-        transportReplays += 1;
-        const retryAfterMs = err.retryAfterSeconds !== void 0 ? err.retryAfterSeconds * 1e3 : void 0;
-        await rt.sleep(
-          retryAfterMs !== void 0 ? Math.min(retryAfterMs, MAX_RETRY_AFTER_MS) : TRANSPORT_REPLAY_DELAY_MS
-        );
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-var LIVENESS_CHAINABLE = /* @__PURE__ */ new Set(["passed", "review", "processing", "skipped"]);
-async function runLivenessFlow(deps) {
-  const { artifacts } = deps;
-  const clip = artifacts.clip;
-  const bareMime = stripMimeParams(artifacts.clipMime ?? "");
-  if (artifacts.degraded === "NO_RECORDER" || clip === void 0 || !CLIP_MIME_ALLOWLIST.includes(bareMime)) {
-    return { kind: "unavailable", reason: "no_recorder" };
-  }
-  const submitLiveness = buildLivenessSubmit(deps, clip, bareMime);
-  const submitFaceMatch = buildFaceMatchSubmit(deps, artifacts.keyframe);
-  let livenessSubmitted = false;
-  let faceMatchSubmitted = false;
-  let livenessChainable = true;
-  let resyncs = 0;
-  for (; ; ) {
-    if (deps.isCancelled()) return { kind: "cancelled" };
-    const view = deps.getView();
-    if (isTerminalView(view)) return { kind: "settled" };
-    const frontier = frontierStep(view)?.checkType;
-    const next = frontier === "liveness" && !livenessSubmitted ? "liveness" : frontier === "face_match" && !faceMatchSubmitted && livenessChainable ? "face_match" : null;
-    if (next === null) return { kind: "settled" };
-    try {
-      if (next === "liveness") {
-        livenessSubmitted = true;
-        const response = await submitLiveness();
-        if (deps.isCancelled()) return { kind: "cancelled" };
-        deps.applySubmit(response, "liveness");
-        const state = stepOf(deps.getView(), "liveness")?.state;
-        livenessChainable = state === void 0 || LIVENESS_CHAINABLE.has(state);
-      } else {
-        faceMatchSubmitted = true;
-        const response = await submitFaceMatch();
-        if (deps.isCancelled()) return { kind: "cancelled" };
-        deps.applySubmit(response, "face_match");
-      }
-    } catch (err) {
-      if (deps.isCancelled()) return { kind: "cancelled" };
-      const outcome = classifyFailure(err);
-      if (outcome.kind !== "resync" || resyncs >= RESYNC_REENTRY_MAX) return outcome;
-      resyncs += 1;
-      await deps.refreshView();
-    }
-  }
-}
-function buildLivenessSubmit(deps, clip, bareMime) {
-  let clipKey = null;
-  let attestation = null;
-  return () => runSubmission(
-    deps,
-    async (client, idempotencyKey) => {
-      if (clipKey === null) {
-        deps.onPhase("uploading");
-        const presigned = await client.presign("clip", bareMime, clip.size);
-        await client.uploadToSpaces(presigned.uploadUrl, clip, bareMime);
-        clipKey = (await client.completeMedia(presigned.key)).key;
-      }
-      if (attestation === null) {
-        try {
-          attestation = await deps.getAttestation();
-        } catch (err) {
-          throw new AttestationError(err instanceof Error ? err.message : String(err));
-        }
-      }
-      deps.onPhase("checking");
-      return client.submitCheck(
-        "liveness",
-        {
-          clipKey,
-          attestation,
-          captureChannel: deps.artifacts.captureChannel,
-          capture: captureInputOf(deps.artifacts)
-        },
-        { idempotencyKey }
-      );
-    },
-    {
-      onAttestationInvalid: () => {
-        attestation = null;
-      }
-    }
-  );
-}
-function captureInputOf(artifacts) {
-  return {
-    ...artifacts.engine !== void 0 ? { engine: artifacts.engine } : {},
-    width: artifacts.width,
-    height: artifacts.height,
-    ...artifacts.clipMs !== void 0 ? { clipMs: artifacts.clipMs } : {},
-    ...artifacts.cameraReadyMs !== void 0 ? { cameraReadyMs: artifacts.cameraReadyMs } : {},
-    ...artifacts.faceAcquireMs !== void 0 ? { faceAcquireMs: artifacts.faceAcquireMs } : {},
-    ...artifacts.captureMs !== void 0 ? { captureMs: artifacts.captureMs } : {}
-  };
-}
-function buildFaceMatchSubmit(deps, keyframe) {
-  let imageKey = null;
-  return () => runSubmission(deps, async (client, idempotencyKey) => {
-    if (imageKey === null) {
-      deps.onPhase("uploading");
-      const presigned = await client.presign("image", KEYFRAME_MIME, keyframe.size);
-      await client.uploadToSpaces(presigned.uploadUrl, keyframe, KEYFRAME_MIME);
-      imageKey = (await client.completeMedia(presigned.key)).key;
-    }
-    deps.onPhase("checking");
-    return client.submitCheck("face_match", { imageKey }, { idempotencyKey });
-  });
-}
-function classifyFailure(err) {
-  if (err instanceof AttestationError) return { kind: "unavailable", reason: "attestation" };
-  if (err instanceof HostedApiError) {
-    if (err.code === "attestation_invalid") return { kind: "unavailable", reason: "attestation" };
-    if (RESYNC_CODES.has(err.code)) return { kind: "resync" };
-  }
-  return { kind: "unavailable", reason: "network" };
-}
-
-// src/verification/turnstile.ts
-var TURNSTILE_SCRIPT_SRC = "https://challenges.cloudflare.com/turnstile/v0/api.js";
-var TURNSTILE_EXECUTE_TIMEOUT_MS = 3e4;
-function installedApi() {
-  return window.turnstile;
-}
-var loaderPromise = null;
-function resetTurnstileForTests() {
-  loaderPromise = null;
-}
-function loadTurnstile() {
-  loaderPromise ?? (loaderPromise = new Promise((resolve, reject) => {
-    const present = installedApi();
-    if (present) {
-      resolve(present);
-      return;
-    }
-    const script = document.createElement("script");
-    script.src = TURNSTILE_SCRIPT_SRC;
-    script.async = true;
-    script.onload = () => {
-      const api = installedApi();
-      if (api) {
-        resolve(api);
-      } else {
-        loaderPromise = null;
-        reject(new Error("Turnstile script loaded but exposed no API"));
-      }
-    };
-    script.onerror = () => {
-      loaderPromise = null;
-      script.remove();
-      reject(new Error("Turnstile script failed to load"));
-    };
-    document.head.appendChild(script);
-  }));
-  return loaderPromise;
-}
-function abortError() {
-  return new Error("Turnstile challenge aborted");
-}
-async function executeTurnstile(siteKey, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? TURNSTILE_EXECUTE_TIMEOUT_MS;
-  const signal = opts.signal;
-  if (signal?.aborted) throw abortError();
-  const api = await loadTurnstile();
-  if (signal?.aborted) throw abortError();
-  const container = document.createElement("div");
-  document.body.appendChild(container);
-  let widgetId;
-  let timer;
-  let onAbort;
-  try {
-    return await new Promise((resolve, reject) => {
-      timer = setTimeout(
-        () => reject(new Error(`Turnstile challenge timed out (${timeoutMs} ms)`)),
-        timeoutMs
-      );
-      if (signal !== void 0) {
-        onAbort = () => reject(abortError());
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      widgetId = api.render(container, {
-        sitekey: siteKey,
-        execution: "execute",
-        appearance: "execute",
-        callback: resolve,
-        "error-callback": (code) => {
-          reject(new Error(`Turnstile challenge failed${code ? ` (${code})` : ""}`));
-        }
-      });
-      if (widgetId === void 0) {
-        reject(new Error("Turnstile render returned no widget id"));
-        return;
-      }
-      api.execute(widgetId);
-    });
-  } finally {
-    clearTimeout(timer);
-    if (signal !== void 0 && onAbort !== void 0) signal.removeEventListener("abort", onAbort);
-    if (widgetId !== void 0) {
-      try {
-        api.remove(widgetId);
-      } catch {
-      }
-    }
-    container.remove();
-  }
-}
-
-// src/verification/create-verification.ts
-var DEFAULT_API_ORIGIN = "https://api.sekyro.ai";
-var REGISTRY_RETRY_DELAY_MS = 5e3;
-var PROCESSING_POLL_DELAY_MS = 1500;
-var PROCESSING_POLL_MAX = 10;
-function defaultSleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function randomUuid() {
-  const c = globalThis.crypto;
-  if (c !== void 0 && typeof c.randomUUID === "function") return c.randomUUID();
-  const bytes = new Uint8Array(16);
-  if (c !== void 0 && typeof c.getRandomValues === "function") c.getRandomValues(bytes);
-  else for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
-  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
-  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function createVerification(options) {
-  return createVerificationInternal(options, {});
-}
-function createVerificationInternal(options, internals) {
-  const apiOrigin = options.apiOrigin ?? DEFAULT_API_ORIGIN;
-  const autoRetry = options.autoRetry ?? true;
-  const rearm = options.rearm ?? "auto";
-  const client = internals.client ?? new HostedClient({
-    apiOrigin,
-    sessionToken: options.clientToken,
-    ...options.fetch !== void 0 ? { fetch: options.fetch } : {}
-  });
-  const sleep = internals.sleep ?? defaultSleep;
-  const uuid = internals.uuid ?? randomUuid;
-  const getTurnstileToken = internals.getTurnstileToken ?? executeTurnstile;
-  const emitter = createEmitter();
-  let destroyed = false;
-  const lifetime = new AbortController();
-  let view = null;
-  let bootstrap = null;
-  const setView = (next) => {
-    view = next;
-    emitter.emit("view", next);
-  };
-  const ensureView = () => {
-    if (view !== null) return Promise.resolve(view);
-    bootstrap ?? (bootstrap = client.getSession().then((next) => {
-      setView(next);
-      return next;
-    }).finally(() => {
-      bootstrap = null;
-    }));
-    return bootstrap;
-  };
-  const refreshView = async () => {
-    const next = await client.getSession();
-    setView(next);
-    return next;
-  };
-  const applySubmit = (response, submitted) => {
-    if (view !== null) setView(mergeSessionView(view, response, submitted));
-  };
-  let consentInFlight = null;
-  const recordConsent = async (force) => {
-    const current = await ensureView();
-    if (!force && current.consentRecorded) return;
-    await client.recordConsent(options.locale);
-    if (view !== null) setView({ ...view, consentRecorded: true });
-  };
-  const ensureConsent = (opts) => {
-    if (opts?.force === true) return recordConsent(true);
-    consentInFlight ?? (consentInFlight = recordConsent(false).finally(() => {
-      consentInFlight = null;
-    }));
-    return consentInFlight;
-  };
-  const runtime = {
-    client,
-    ensureConsent: (opts) => ensureConsent(opts),
-    sleep,
-    uuid
-  };
-  let terminalEmitted = false;
-  const emitResult = (result) => {
-    if (result.status === "approved" || result.status === "rejected" || result.status === "review") {
-      if (terminalEmitted) return;
-      terminalEmitted = true;
-    }
-    emitter.emit("result", result);
-  };
-  let registry2 = null;
-  let registryFailed = false;
-  let registryUnbound = false;
-  const submitRegistry = () => runSubmission(
-    runtime,
-    (c, idempotencyKey) => (
-      // `{}` input: the session is bound to a SERVER-provided NNI (Plan A Task 2).
-      c.submitCheck("population_registry", {}, { idempotencyKey })
-    )
-  );
-  const runRegistry = async () => {
-    try {
-      const current = await ensureView();
-      if (isTerminalView(current) || frontierStep(current)?.checkType !== "population_registry") {
-        return;
-      }
-      if (current.nniBound !== true) {
-        registryUnbound = true;
-        return;
-      }
-      await ensureConsent();
-      applySubmit(await submitRegistry(), "population_registry");
-      const step = view === null ? void 0 : stepOf(view, "population_registry");
-      if (step?.state === "input_required" && step.reason === "registry_unavailable" && step.attemptsRemaining > 0) {
-        await sleep(REGISTRY_RETRY_DELAY_MS);
-        if (destroyed) return;
-        applySubmit(await submitRegistry(), "population_registry");
-      }
-    } catch {
-      registryFailed = true;
-      return;
-    }
-    if (view !== null && isTerminalView(view)) emitResult(mapSessionResult(view, { autoRetry }));
-  };
-  const startRegistry = () => {
-    registry2 ?? (registry2 = runRegistry());
-    return registry2;
-  };
-  const getAttestation = async () => {
-    const current = await ensureView();
-    const siteKey = current.turnstileSiteKey;
-    if (siteKey === null) return { sandbox: true };
-    return {
-      channel: "hosted_web",
-      siteKey,
-      turnstileToken: await getTurnstileToken(siteKey, { signal: lifetime.signal })
-    };
-  };
-  let active = null;
-  let chain = Promise.resolve();
-  let chainDepth = 0;
-  const settleProcessing = async () => {
-    let current = await ensureView();
-    for (let i = 0; i < PROCESSING_POLL_MAX && !destroyed && !isTerminalView(current) && frontierStep(current) === void 0 && current.steps.some((step) => step.state === "processing"); i += 1) {
-      await sleep(PROCESSING_POLL_DELAY_MS);
-      if (destroyed) break;
-      current = await refreshView();
-    }
-    return current;
-  };
-  const runFlow = async (bound, artifacts, capturedAttempt) => {
-    const { capture } = bound;
-    const isCancelled = () => destroyed;
-    const ownsHandle = () => bound.alive && bound.attempt === capturedAttempt;
-    const setPhase = (phase) => {
-      if (ownsHandle()) capture.setFlowState(phase);
-    };
-    const finish = (result) => {
-      if (isCancelled()) return;
-      emitResult(result);
-      if (!ownsHandle()) return;
-      if (result.status === "retry" && rearm === "auto") {
-        capture.handle.retry();
-        return;
-      }
-      capture.setFlowState("done");
-    };
-    if (artifacts.degraded === "NO_RECORDER") {
-      const sessionId = view?.sessionId ?? (await ensureView().catch(() => null))?.sessionId ?? "";
-      finish(unavailable(sessionId, "no_recorder"));
-      return;
-    }
-    setPhase("uploading");
-    try {
-      await startRegistry();
-      if (isCancelled()) return;
-      let current = await ensureView();
-      if (!isTerminalView(current)) {
-        if (frontierStep(current)?.checkType === "population_registry") {
-          finish(
-            unavailable(
-              current.sessionId,
-              registryUnbound ? "nni_unbound" : registryFailed ? "network" : "registry_unavailable"
-            )
-          );
-          return;
-        }
-        await ensureConsent();
-        if (isCancelled()) return;
-        const outcome = await runLivenessFlow({
-          ...runtime,
-          artifacts,
-          getAttestation,
-          getView: () => view ?? current,
-          refreshView,
-          applySubmit,
-          onPhase: setPhase,
-          isCancelled
-        });
-        if (isCancelled()) return;
-        if (outcome.kind === "unavailable") {
-          finish(unavailable(current.sessionId, outcome.reason));
-          return;
-        }
-        if (outcome.kind === "resync") await refreshView();
-        current = await settleProcessing();
-      }
-      finish(mapSessionResult(current, { autoRetry }));
-    } catch {
-      if (isCancelled()) return;
-      finish(unavailable(view?.sessionId ?? "", "network"));
-    }
-  };
-  const enqueueFlow = (bound, artifacts) => {
-    const capturedAttempt = bound.attempt;
-    if (chainDepth > 0 && bound.alive) {
-      bound.capture.setFlowState("uploading");
-    }
-    chainDepth += 1;
-    chain = chain.then(() => runFlow(bound, artifacts, capturedAttempt)).finally(() => {
-      chainDepth -= 1;
-    }).catch(() => void 0);
-  };
-  const liveness = (captureOptions) => {
-    active?.capture.handle.destroy();
-    if (active !== null) active.alive = false;
-    const capture = createLivenessCaptureInternal(captureOptions, internals.capture);
-    const bound = { capture, alive: true, attempt: 0 };
-    active = bound;
-    capture.handle.on("state", (state) => {
-      if (state === "starting") bound.attempt += 1;
-    });
-    capture.handle.on("captured", (artifacts) => {
-      void Promise.resolve().then(() => enqueueFlow(bound, artifacts));
-    });
-    const inner = capture.handle;
-    return {
-      get state() {
-        return inner.state;
-      },
-      on: (event, handler) => inner.on(event, handler),
-      start: (startOptions) => inner.start(startOptions),
-      retry: () => inner.retry(),
-      switchCamera: () => inner.switchCamera(),
-      destroy: () => {
-        bound.alive = false;
-        if (active === bound) active = null;
-        inner.destroy();
-      }
-    };
-  };
-  return {
-    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;
-      lifetime.abort();
-      if (active !== null) {
-        active.alive = false;
-        active.capture.handle.destroy();
-        active = null;
-      }
-      emitter.clear();
-    }
-  };
-}
-
-export {
-  PRELOAD_BLAZE_INIT_TIMEOUT_MS,
-  PRELOAD_BUDGET_MS,
-  setPreloadLoaderForTests,
-  resetLivenessAssetsForTests,
-  preloadLivenessAssets,
-  getLivenessAssetsStatus,
-  subscribeLivenessAssets,
-  releaseLivenessAssets,
-  preloadedDetectorFactory,
-  mapGuidanceHint,
-  mapEngineState,
-  mapErrorKind,
-  createLivenessCaptureInternal,
-  createLivenessCapture,
-  RETRYABLE_REASONS,
-  isExecutable,
-  isTerminalView,
-  frontierStep,
-  stepOf,
-  mergeSessionView,
-  mapSessionResult,
-  CLIP_MIME_ALLOWLIST,
-  TRANSPORT_REPLAY_ATTEMPTS,
-  TRANSPORT_REPLAY_DELAY_MS,
-  AttestationError,
-  runSubmission,
-  runLivenessFlow,
-  TURNSTILE_SCRIPT_SRC,
-  TURNSTILE_EXECUTE_TIMEOUT_MS,
-  resetTurnstileForTests,
-  loadTurnstile,
-  executeTurnstile,
-  DEFAULT_API_ORIGIN,
-  REGISTRY_RETRY_DELAY_MS,
-  PROCESSING_POLL_DELAY_MS,
-  PROCESSING_POLL_MAX,
-  randomUuid,
-  createVerification,
-  createVerificationInternal
-};
-//# sourceMappingURL=chunk-R3SJQHYU.js.map