@sekyro/web 0.0.0-stage → 0.1.0-rc.2

package/dist/chunk-BPYVZUJA.js

@@ -0,0 +1,852 @@
+import {
+  CaptureSessionV3,
+  detectIsMobile,
+  isMediaRecorderSupported
+} from "./chunk-LOTAJDRE.js";
+import {
+  HostedApiError,
+  HostedClient,
+  stripMimeParams
+} from "./chunk-YVFF4Q4G.js";
+
+// 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/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 engineOptions = {
+    video: options.video,
+    mode: degraded ? "photo" : "clip",
+    ...options.facing !== void 0 ? { facingMode: options.facing } : {},
+    ...options.assetBaseUrl !== void 0 ? { v3AssetBaseUrl: options.assetBaseUrl } : {},
+    ...internals.engineOptions ?? {}
+  };
+  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;
+  const setState = (next) => {
+    state = next;
+    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;
+      }
+      setState(next);
+      syncProfile();
+      if (next === "recording") {
+        recordingStartedAt = now();
+        hint = "hold";
+        progress = 1;
+        emitGate();
+      }
+    }),
+    engine.on("checks", (payload) => {
+      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,
+        height: options.video.videoHeight,
+        ...clipMs !== void 0 ? { clipMs } : {},
+        captureChannel: detectIsMobile() ? "mobile" : "desktop",
+        ...degraded ? { degraded: "NO_RECORDER" } : {}
+      });
+    }),
+    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: () => engine.start(),
+    retry: () => engine.retry(),
+    switchCamera: () => engine.switchCamera(),
+    destroy: () => {
+      for (const unsubscribe of unsubscribes) unsubscribe();
+      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 },
+        { idempotencyKey }
+      );
+    },
+    {
+      onAttestationInvalid: () => {
+        attestation = null;
+      }
+    }
+  );
+}
+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 registry = 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 = () => {
+    registry ?? (registry = runRegistry());
+    return registry;
+  };
+  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: () => inner.start(),
+      retry: () => inner.retry(),
+      switchCamera: () => inner.switchCamera(),
+      destroy: () => {
+        bound.alive = false;
+        if (active === bound) active = null;
+        inner.destroy();
+      }
+    };
+  };
+  return {
+    consent: () => ensureConsent(),
+    startRegistry,
+    liveness,
+    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 {
+  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-BPYVZUJA.js.map