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

package/dist/index.cjs

@@ -0,0 +1,2636 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_API_ORIGIN: () => DEFAULT_API_ORIGIN,
+  HostedApiError: () => HostedApiError,
+  KNOWN_CODES: () => KNOWN_CODES,
+  SEKYRO_EVENTS: () => SEKYRO_EVENTS,
+  createLivenessCapture: () => createLivenessCapture,
+  createVerification: () => createVerification,
+  isKnownCode: () => isKnownCode,
+  openHosted: () => openHosted
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/capture-constraints.ts
+function buildCaptureConstraints(isMobile, facingMode) {
+  void isMobile;
+  return {
+    video: {
+      width: { ideal: 1280, max: 1280 },
+      height: { ideal: 720, max: 720 },
+      facingMode,
+      frameRate: { ideal: 24, max: 30 }
+    },
+    audio: false
+  };
+}
+function detectIsMobile() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+  return window.innerWidth <= 768 || /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+    String(navigator.userAgent ?? "")
+  );
+}
+
+// src/core/media.ts
+var MIME_CANDIDATES = [
+  "video/mp4;codecs=avc1.42E01E,mp4a.40.2",
+  "video/mp4;codecs=avc1.42E01E",
+  "video/mp4",
+  "video/webm;codecs=vp9,opus",
+  "video/webm;codecs=vp9",
+  "video/webm;codecs=vp8,opus",
+  "video/webm;codecs=vp8",
+  "video/webm"
+];
+function pickMimeType() {
+  const MR = globalThis.MediaRecorder;
+  if (!MR || typeof MR.isTypeSupported !== "function") return "";
+  return MIME_CANDIDATES.find((t) => MR.isTypeSupported(t)) ?? "";
+}
+var DEFAULT_CLIP_MIME = "video/webm";
+function mapGetUserMediaError(err) {
+  if (err instanceof TypeError) return "insecure";
+  const name = err?.name ?? "";
+  switch (name) {
+    case "NotAllowedError":
+    case "PermissionDeniedError":
+      return "permission";
+    case "NotFoundError":
+    case "DevicesNotFoundError":
+      return "notfound";
+    case "NotReadableError":
+    case "TrackStartError":
+      return "inuse";
+    case "OverconstrainedError":
+    case "ConstraintNotSatisfiedError":
+      return "overconstrained";
+    default:
+      return "generic";
+  }
+}
+function cameraPreflight() {
+  const w = globalThis;
+  if (typeof w.window !== "undefined" && w.window.isSecureContext === false)
+    return "INSECURE_CONTEXT";
+  const md = w.navigator?.mediaDevices;
+  if (!md || typeof md.getUserMedia !== "function") return "UNSUPPORTED";
+  return "OK";
+}
+function isMediaRecorderSupported() {
+  const MR = globalThis.MediaRecorder;
+  return typeof MR !== "undefined" && typeof MR.isTypeSupported === "function";
+}
+var MAX_CLIP_BYTES = 8 * 1024 * 1024;
+function isClipTooLarge(blob) {
+  return blob.size > MAX_CLIP_BYTES;
+}
+
+// src/core/clip-recorder.ts
+var CLIP_MS = 2500;
+var TIMESLICE_MS = 1e3;
+var STOP_GRACE_MS = 1500;
+var VIDEO_BPS = 25e5;
+var ClipError = class extends Error {
+  constructor(kind, msg) {
+    super(msg ?? kind);
+    this.kind = kind;
+  }
+};
+var ClipRecorder = class {
+  constructor() {
+    this.recorder = null;
+    this.stream = null;
+    // own field so teardown can stop tracks (REVIEW FIX 8)
+    this.chunks = [];
+    this.bytes = 0;
+    this.hardStopTimer = null;
+    this.graceTimer = null;
+    this.settled = false;
+  }
+  clearTimers() {
+    if (this.hardStopTimer) clearTimeout(this.hardStopTimer);
+    if (this.graceTimer) clearTimeout(this.graceTimer);
+    this.hardStopTimer = null;
+    this.graceTimer = null;
+  }
+  /** Records CLIP_MS of the stream. Resolves with the clip blob + its container mime;
+   *  rejects with ClipError. Behavior contract is the v1 hook's `start`, verbatim
+   *  (iOS workarounds included).
+   *
+   *  ONE RECORDING AT A TIME: chunk/byte/timer state is shared per instance, so a
+   *  second record() while one is in flight rejects ClipError("generic") instead of
+   *  corrupting the in-flight clip. (v2 guard — v1's hook was gated by its owning
+   *  component; a class API invites reuse. Zero impact on clip bytes.)
+   *
+   *  `onStopped` (optional) fires ONCE the moment the CLIP_MS recording window
+   *  elapses (the hard-stop), BEFORE finalize — which on iOS can lag up to
+   *  STOP_GRACE_MS while onstop flushes the last chunk. It lets the host freeze
+   *  the display on the already-captured keyframe the instant recording ends,
+   *  instead of waiting for the blob. PURE NOTIFICATION — it does not touch
+   *  timers, chunks, or the finalize path, so it is calibration-neutral (no
+   *  effect on clip bytes). Never fires on a rejected capture (error /
+   *  cliptoolarge settle before the hard-stop and clear the timer). */
+  record(stream, onStopped) {
+    if (this.recorder && !this.settled) {
+      return Promise.reject(
+        new ClipError(
+          "generic",
+          "record() called while a recording is in flight \u2014 ClipRecorder handles one recording at a time"
+        )
+      );
+    }
+    this.recorder = null;
+    this.clearTimers();
+    this.chunks = [];
+    this.bytes = 0;
+    this.settled = false;
+    this.stream = stream;
+    const picked = pickMimeType();
+    return new Promise((resolve, reject) => {
+      let recorder;
+      try {
+        recorder = new MediaRecorder(
+          stream,
+          picked ? { mimeType: picked, videoBitsPerSecond: VIDEO_BPS } : { videoBitsPerSecond: VIDEO_BPS }
+        );
+      } catch {
+        try {
+          recorder = new MediaRecorder(stream);
+        } catch {
+          reject(new ClipError("unsupported"));
+          return;
+        }
+      }
+      this.recorder = recorder;
+      const settle = (fn) => {
+        if (this.settled) return;
+        this.settled = true;
+        this.clearTimers();
+        fn();
+      };
+      const finalize = () => settle(() => {
+        const type = recorder.mimeType || picked || DEFAULT_CLIP_MIME;
+        const blob = new Blob(this.chunks, { type });
+        if (isClipTooLarge(blob)) {
+          reject(new ClipError("cliptoolarge"));
+          return;
+        }
+        resolve({ blob, mimeType: type });
+      });
+      recorder.ondataavailable = (e) => {
+        if (e.data && e.data.size) {
+          this.chunks.push(e.data);
+          this.bytes += e.data.size;
+          if (this.bytes > MAX_CLIP_BYTES) {
+            settle(() => {
+              try {
+                if (recorder.state !== "inactive") recorder.stop();
+              } catch {
+              }
+              reject(new ClipError("cliptoolarge"));
+            });
+          }
+        }
+      };
+      recorder.onstop = finalize;
+      recorder.onerror = () => settle(() => reject(new ClipError("generic")));
+      try {
+        recorder.start(TIMESLICE_MS);
+      } catch {
+        settle(() => reject(new ClipError("generic")));
+        return;
+      }
+      this.hardStopTimer = setTimeout(() => {
+        if (!this.settled) onStopped?.();
+        if (recorder.state !== "inactive") {
+          try {
+            recorder.stop();
+          } catch {
+            finalize();
+          }
+          this.graceTimer = setTimeout(finalize, STOP_GRACE_MS);
+        } else {
+          finalize();
+        }
+      }, CLIP_MS);
+    });
+  }
+  /** Idempotent teardown: stop recorder + ALL tracks (v1 `stopAndCleanup` + the unmount
+   *  effect). Optional `stream` override mirrors v1's `stopAndCleanup(stream?)`.
+   *
+   *  MID-RECORDING SEMANTICS (verbatim v1): calling stop() while a record() is in
+   *  flight may LATER resolve the pending promise with a TRUNCATED clip (recorder.stop()
+   *  fires onstop → finalize from whatever chunks arrived so far), or — because this
+   *  method clears the hard-stop/grace timers — never settle it at all if onstop never
+   *  fires (the iOS grace path has been torn down). Callers MUST NOT treat a resolution
+   *  arriving after stop() as a full CLIP_MS clip, and must not await a record()
+   *  promise past stop() without their own timeout. (Task 4's CaptureSession owns
+   *  sequencing on top of this contract.) */
+  stop(stream) {
+    this.clearTimers();
+    const rec = this.recorder;
+    if (rec && rec.state !== "inactive") {
+      try {
+        rec.stop();
+      } catch {
+      }
+    }
+    this.recorder = null;
+    const s = stream ?? this.stream;
+    s?.getTracks().forEach((t) => t.stop());
+    this.stream = null;
+  }
+};
+
+// src/core/keyframe.ts
+function captureMirroredKeyframe(video, canvas, quality = 0.92) {
+  return new Promise((resolve, reject) => {
+    const w = video.videoWidth;
+    const h = video.videoHeight;
+    if (!w || !h) {
+      reject(new Error("video-not-ready"));
+      return;
+    }
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      reject(new Error("no-2d-context"));
+      return;
+    }
+    canvas.width = w;
+    canvas.height = h;
+    ctx.scale(-1, 1);
+    ctx.drawImage(video, -w, 0);
+    canvas.toBlob(
+      (blob) => blob ? resolve(blob) : reject(new Error("empty-keyframe")),
+      "image/jpeg",
+      quality
+    );
+  });
+}
+
+// src/core/v3/detector-blaze.ts
+var BLAZE_INIT_TIMEOUT_MS = 1e4;
+var BlazeDetector = class _BlazeDetector {
+  constructor(inner, fallbackReason) {
+    this.tier = "blaze";
+    this.inner = inner;
+    if (fallbackReason !== void 0) this.fallbackReason = fallbackReason;
+  }
+  static async create(assetBaseUrl, fallbackReason) {
+    const vision = await import("@mediapipe/tasks-vision");
+    const fileset = await vision.FilesetResolver.forVisionTasks(assetBaseUrl);
+    const inner = await vision.FaceDetector.createFromOptions(fileset, {
+      baseOptions: {
+        modelAssetPath: `${assetBaseUrl}/blaze_face_short_range.tflite`,
+        // CPU delegate — the iOS-Safari-safe path (see header). NEVER 'GPU'.
+        delegate: "CPU"
+      },
+      runningMode: "IMAGE"
+    });
+    return new _BlazeDetector(inner, fallbackReason);
+  }
+  async detect(source, sourceWidth, sourceHeight) {
+    let detections;
+    try {
+      detections = this.inner.detect(source).detections;
+    } catch {
+      return null;
+    }
+    const best = pickMostConfident(detections);
+    if (best?.boundingBox === void 0) return null;
+    const size = intrinsicSize(source);
+    const eyes = extractEyes(best.keypoints, size);
+    const observation = {
+      box: {
+        x: best.boundingBox.originX,
+        y: best.boundingBox.originY,
+        width: best.boundingBox.width,
+        height: best.boundingBox.height
+      },
+      ...eyes !== void 0 ? { eyes } : {},
+      score: best.categories[0]?.score ?? 0
+    };
+    return toStreamPixels(observation, source, sourceWidth, sourceHeight);
+  }
+  destroy() {
+    try {
+      this.inner.close();
+    } catch {
+    }
+  }
+};
+function pickMostConfident(detections) {
+  let best;
+  let bestScore = -1;
+  for (const detection of detections) {
+    const score = detection.categories[0]?.score ?? 0;
+    if (score > bestScore) {
+      best = detection;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+function extractEyes(keypoints, size) {
+  const a = keypoints?.[0];
+  const b = keypoints?.[1];
+  if (a === void 0 || b === void 0) return void 0;
+  const toSource = (p) => ({ x: p.x * size.width, y: p.y * size.height });
+  const [pa, pb] = [toSource(a), toSource(b)];
+  return pa.x <= pb.x ? { left: pa, right: pb } : { left: pb, right: pa };
+}
+
+// src/core/v3/detector-native.ts
+function smokeSource() {
+  if (typeof OffscreenCanvas === "function") return new OffscreenCanvas(2, 2);
+  const canvas = document.createElement("canvas");
+  canvas.width = 2;
+  canvas.height = 2;
+  return canvas;
+}
+async function probeNativeDetector() {
+  const ctor = globalThis.FaceDetector;
+  if (typeof ctor !== "function") return { ok: false, reason: "unsupported" };
+  try {
+    const instance = new ctor({ fastMode: true, maxDetectedFaces: 1 });
+    await instance.detect(smokeSource());
+    return { ok: true, instance };
+  } catch (err) {
+    return { ok: false, reason: `smoke_failed:${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var NativeDetector = class {
+  constructor(inner, fallbackReason) {
+    this.tier = "native";
+    this.inner = inner;
+    if (fallbackReason !== void 0) this.fallbackReason = fallbackReason;
+  }
+  async detect(source, sourceWidth, sourceHeight) {
+    let faces;
+    try {
+      faces = await this.inner.detect(source);
+    } catch {
+      return null;
+    }
+    const face = faces[0];
+    if (face === void 0) return null;
+    const eyes = extractEyes2(face.landmarks);
+    const observation = {
+      box: {
+        x: face.boundingBox.x,
+        y: face.boundingBox.y,
+        width: face.boundingBox.width,
+        height: face.boundingBox.height
+      },
+      ...eyes !== void 0 ? { eyes } : {},
+      // The Shape Detection API exposes no confidence — the smoke-tested
+      // native tier treats any detection as confident.
+      score: 1
+    };
+    return toStreamPixels(observation, source, sourceWidth, sourceHeight);
+  }
+  destroy() {
+  }
+};
+function extractEyes2(landmarks) {
+  if (landmarks === void 0) return void 0;
+  const eyePoints = landmarks.filter((landmark) => landmark.type === "eye").map((landmark) => landmark.locations[0]).filter((point) => point !== void 0);
+  const [a, b] = eyePoints;
+  if (a === void 0 || b === void 0) return void 0;
+  return a.x <= b.x ? { left: a, right: b } : { left: b, right: a };
+}
+
+// src/core/v3/detector.ts
+var DEFAULT_V3_ASSET_BASE_URL = "/models-v3";
+var DEFAULT_TIER_ORDER = ["native", "blaze"];
+var DetectorLadderError = class extends Error {
+  constructor(fallbackReason) {
+    super(`no detector tier available (${fallbackReason})`);
+    this.name = "DetectorLadderError";
+    this.fallbackReason = fallbackReason;
+  }
+};
+function intrinsicSize(source) {
+  const candidate = source;
+  if (typeof candidate.videoWidth === "number" && candidate.videoWidth > 0) {
+    return { width: candidate.videoWidth, height: candidate.videoHeight ?? 0 };
+  }
+  if (typeof candidate.naturalWidth === "number" && candidate.naturalWidth > 0) {
+    return { width: candidate.naturalWidth, height: candidate.naturalHeight ?? 0 };
+  }
+  const width = typeof candidate.width === "number" ? candidate.width : 0;
+  const height = typeof candidate.height === "number" ? candidate.height : 0;
+  return { width, height };
+}
+function toStreamPixels(observation, source, streamWidth, streamHeight) {
+  const size = intrinsicSize(source);
+  const scaleX = size.width > 0 ? streamWidth / size.width : 1;
+  const scaleY = size.height > 0 ? streamHeight / size.height : 1;
+  const scalePoint = (p) => ({ x: p.x * scaleX, y: p.y * scaleY });
+  return {
+    box: {
+      x: observation.box.x * scaleX,
+      y: observation.box.y * scaleY,
+      width: observation.box.width * scaleX,
+      height: observation.box.height * scaleY
+    },
+    ...observation.eyes !== void 0 ? { eyes: { left: scalePoint(observation.eyes.left), right: scalePoint(observation.eyes.right) } } : {},
+    score: observation.score
+  };
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function createDetector(options) {
+  const order = options.preferred ?? DEFAULT_TIER_ORDER;
+  const reasons = [];
+  for (const tier of order) {
+    if (tier === "native") {
+      const probed = await probeNativeDetector();
+      if (probed.ok) {
+        return new NativeDetector(probed.instance, reasonOf(reasons));
+      }
+      reasons.push(`native:${probed.reason}`);
+      continue;
+    }
+    try {
+      return await withTimeout(
+        BlazeDetector.create(
+          options.v3AssetBaseUrl ?? DEFAULT_V3_ASSET_BASE_URL,
+          reasonOf(reasons)
+        ),
+        options.blazeInitTimeoutMs ?? BLAZE_INIT_TIMEOUT_MS
+      );
+    } catch (err) {
+      reasons.push(
+        err instanceof InitTimeoutError ? "blaze:blaze_init_timeout" : `blaze:${describeError(err)}`
+      );
+    }
+  }
+  throw new DetectorLadderError(reasonOf(reasons) ?? "no_tier_available");
+}
+function reasonOf(reasons) {
+  return reasons.length > 0 ? reasons.join("; ") : void 0;
+}
+var InitTimeoutError = class extends Error {
+};
+function withTimeout(promise, deadlineMs) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const timer = setTimeout(() => {
+      rejectPromise(new InitTimeoutError(`init exceeded ${deadlineMs}ms`));
+      promise.then(
+        (value) => value.destroy(),
+        () => void 0
+      );
+    }, deadlineMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolvePromise(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      }
+    );
+  });
+}
+
+// src/core/v3/detect-worker.ts
+var WORKER_PROTOCOL_VERSION = 1;
+function workerOffloadSupported() {
+  return typeof OffscreenCanvas === "function" && typeof createImageBitmap === "function" && typeof Worker === "function";
+}
+function installWorkerDetectorHost(scope, deps = {}) {
+  const create = deps.createDetector ?? createDetector;
+  let detector = null;
+  scope.onmessage = (event) => {
+    const message = event.data;
+    if (message.v !== WORKER_PROTOCOL_VERSION) {
+      message.bitmap?.close?.();
+      return;
+    }
+    if (message.type === "init") {
+      void create(message.options).then((created) => {
+        detector = created;
+        const ready = {
+          v: WORKER_PROTOCOL_VERSION,
+          type: "ready",
+          tier: created.tier,
+          ...created.fallbackReason !== void 0 ? { fallbackReason: created.fallbackReason } : {}
+        };
+        scope.postMessage(ready);
+      });
+      return;
+    }
+    if (message.type === "detect") {
+      const respond = (observation) => {
+        const result = {
+          v: WORKER_PROTOCOL_VERSION,
+          type: "result",
+          id: message.id,
+          observation
+        };
+        scope.postMessage(result);
+        message.bitmap.close?.();
+      };
+      if (detector === null) {
+        respond(null);
+        return;
+      }
+      void detector.detect(message.bitmap, message.streamWidth, message.streamHeight).then(respond, () => respond(null));
+    }
+  };
+}
+if (typeof self !== "undefined" && typeof self.importScripts === "function") {
+  installWorkerDetectorHost(self);
+}
+var WorkerDetectorProxy = class _WorkerDetectorProxy {
+  constructor(worker, ready) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.worker = worker;
+    this.tier = ready.tier;
+    if (ready.fallbackReason !== void 0) this.fallbackReason = ready.fallbackReason;
+    worker.addEventListener("message", (event) => {
+      const message = event.data;
+      if (message.v !== WORKER_PROTOCOL_VERSION || message.type !== "result") return;
+      const resolve = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      resolve?.(message.observation);
+    });
+  }
+  static create(worker, options, readyTimeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        worker.removeEventListener("message", onReady);
+        worker.terminate();
+        reject(new Error(`worker detector not ready within ${readyTimeoutMs}ms`));
+      }, readyTimeoutMs);
+      const onReady = (event) => {
+        const message = event.data;
+        if (message.v !== WORKER_PROTOCOL_VERSION || message.type !== "ready") return;
+        clearTimeout(timer);
+        worker.removeEventListener("message", onReady);
+        resolve(new _WorkerDetectorProxy(worker, message));
+      };
+      worker.addEventListener("message", onReady);
+      const init = { v: WORKER_PROTOCOL_VERSION, type: "init", options };
+      worker.postMessage(init);
+    });
+  }
+  async detect(source, sourceWidth, sourceHeight) {
+    let bitmap;
+    try {
+      if (typeof ImageBitmap !== "undefined" && source instanceof ImageBitmap) {
+        bitmap = source;
+      } else if (typeof createImageBitmap === "function") {
+        bitmap = await createImageBitmap(source);
+      } else {
+        bitmap = source;
+      }
+    } catch {
+      return null;
+    }
+    const id = this.nextId;
+    this.nextId += 1;
+    return new Promise((resolve) => {
+      this.pending.set(id, resolve);
+      const message = {
+        v: WORKER_PROTOCOL_VERSION,
+        type: "detect",
+        id,
+        bitmap,
+        streamWidth: sourceWidth,
+        streamHeight: sourceHeight
+      };
+      this.worker.postMessage(message, [bitmap]);
+    });
+  }
+  destroy() {
+    for (const resolve of this.pending.values()) resolve(null);
+    this.pending.clear();
+    this.worker.terminate();
+  }
+};
+
+// src/core/v3/device-profile.ts
+var DEVICE_PROFILES = Object.freeze({
+  LOW: Object.freeze({ cadenceHz: 5, inputWidth: 128, animations: "reduced" }),
+  MID: Object.freeze({ cadenceHz: 8, inputWidth: 160, animations: "full" }),
+  HIGH: Object.freeze({ cadenceHz: 10, inputWidth: 192, animations: "full" })
+});
+var SIMD_TEST_BYTES = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  1,
+  0,
+  0,
+  0,
+  1,
+  5,
+  1,
+  96,
+  0,
+  1,
+  123,
+  3,
+  2,
+  1,
+  0,
+  10,
+  10,
+  1,
+  8,
+  0,
+  65,
+  0,
+  253,
+  15,
+  253,
+  98,
+  11
+]);
+function probeDevice() {
+  const nav = typeof navigator === "undefined" ? void 0 : navigator;
+  let simd = false;
+  try {
+    simd = typeof WebAssembly !== "undefined" && WebAssembly.validate(SIMD_TEST_BYTES);
+  } catch {
+    simd = false;
+  }
+  return {
+    cores: nav?.hardwareConcurrency ?? 2,
+    memGB: nav?.deviceMemory ?? null,
+    simd
+  };
+}
+function classifyDevice(probe) {
+  const memGB = probe.memGB ?? 4;
+  if (probe.cores < 4 || memGB < 3) return "LOW";
+  if (probe.cores >= 8 && memGB >= 6) return "HIGH";
+  return "MID";
+}
+var ORDER = ["LOW", "MID", "HIGH"];
+var DeviceProfiler = class {
+  constructor(initial) {
+    this.samples = [];
+    this.adjusted = false;
+    this.current = initial;
+  }
+  get deviceClass() {
+    return this.current;
+  }
+  get profile() {
+    return DEVICE_PROFILES[this.current];
+  }
+  record(detectMs) {
+    if (this.adjusted || this.samples.length >= 10) return this.current;
+    this.samples.push(detectMs);
+    if (this.samples.length < 10) return this.current;
+    this.adjusted = true;
+    const mean = this.samples.reduce((sum, value) => sum + value, 0) / this.samples.length;
+    if (mean > 70) {
+      this.current = "LOW";
+    } else if (mean < 25) {
+      const index = ORDER.indexOf(this.current);
+      this.current = ORDER[Math.min(ORDER.length - 1, index + 1)] ?? this.current;
+    }
+    return this.current;
+  }
+};
+
+// src/core/v3/detect-scheduler.ts
+var STATS_WINDOW = 20;
+var DetectScheduler = class {
+  constructor(options) {
+    this.timer = null;
+    this.frameCallbackId = null;
+    this.running = false;
+    this.busy = false;
+    this.lastRunAt = Number.NEGATIVE_INFINITY;
+    this.degradeCount = 0;
+    this.durations = [];
+    this.options = options;
+    this.periodMs = 1e3 / options.cadenceHz;
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    const video = this.options.video;
+    if (typeof video?.requestVideoFrameCallback === "function") {
+      const loop = () => {
+        if (!this.running) return;
+        this.frameCallbackId = video.requestVideoFrameCallback?.(() => {
+          this.frameCallbackId = null;
+          if (this.now() - this.lastRunAt >= this.periodMs) this.tick();
+          loop();
+        });
+      };
+      loop();
+      return;
+    }
+    this.timer = setInterval(() => this.tick(), this.periodMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.frameCallbackId !== null) {
+      this.options.video?.cancelVideoFrameCallback?.(
+        this.frameCallbackId
+      );
+      this.frameCallbackId = null;
+    }
+  }
+  stats() {
+    const meanDetectMs = this.durations.length === 0 ? 0 : this.durations.reduce((sum, value) => sum + value, 0) / this.durations.length;
+    return { degradeCount: this.degradeCount, meanDetectMs };
+  }
+  now() {
+    return this.options.now?.() ?? performance.now();
+  }
+  tick() {
+    if (!this.running) return;
+    if (this.busy) {
+      this.degradeCount += 1;
+      return;
+    }
+    this.busy = true;
+    this.lastRunAt = this.now();
+    const startedAt = this.now();
+    this.options.run().catch(() => void 0).finally(() => {
+      this.busy = false;
+      this.durations.push(this.now() - startedAt);
+      if (this.durations.length > STATS_WINDOW) this.durations.shift();
+    });
+  }
+};
+
+// src/core/v3/frame-quality.ts
+var SHARP_REF = 180;
+var EXPOSURE_BAND = [100, 190];
+var EXPOSURE_FALLOFF = 64;
+function lumaAt(data, index) {
+  return 0.299 * (data[index] ?? 0) + 0.587 * (data[index + 1] ?? 0) + 0.114 * (data[index + 2] ?? 0);
+}
+function meanLuma(image) {
+  const { data, width, height } = image;
+  const pixels = width * height;
+  if (pixels === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < pixels; i += 1) sum += lumaAt(data, i * 4);
+  return sum / pixels;
+}
+function sharpness(image) {
+  const { data, width, height } = image;
+  if (width < 3 || height < 3) return 0;
+  const gray = new Float32Array(width * height);
+  for (let i = 0; i < gray.length; i += 1) gray[i] = lumaAt(data, i * 4);
+  let sum = 0;
+  let sumSquares = 0;
+  let count = 0;
+  for (let y = 1; y < height - 1; y += 1) {
+    for (let x = 1; x < width - 1; x += 1) {
+      const i = y * width + x;
+      const response = (gray[i - width] ?? 0) + (gray[i - 1] ?? 0) + (gray[i + 1] ?? 0) + (gray[i + width] ?? 0) - 4 * (gray[i] ?? 0);
+      sum += response;
+      sumSquares += response * response;
+      count += 1;
+    }
+  }
+  if (count === 0) return 0;
+  const mean = sum / count;
+  const variance = sumSquares / count - mean * mean;
+  return Math.min(1, Math.max(0, variance) / SHARP_REF);
+}
+function exposure(image) {
+  const mean = meanLuma(image);
+  const [low, high] = EXPOSURE_BAND;
+  const distance = mean < low ? low - mean : mean > high ? mean - high : 0;
+  return Math.max(0, 1 - distance / EXPOSURE_FALLOFF);
+}
+
+// src/core/v3/face-gate-v3.ts
+var V3_GATE_DEFAULTS = Object.freeze({
+  Q_GOOD: 0.6,
+  RISE_PER_S: 0.9,
+  FALL_PER_S: 0.25,
+  CENTER_FALLOFF_IOD_MULTIPLE: 1.35,
+  BOX_EYE_OFFSET_FACTOR: 0.12,
+  IOD_BOX_PROXY_FACTOR: 0.42,
+  SIZE_IDEAL_MIN: 0.12,
+  SIZE_IDEAL_MAX: 0.3,
+  SIZE_HARD_MIN: 0.08,
+  SIZE_HARD_MAX: 0.45,
+  ROLL_MAX_DEG: 25,
+  MOTION_VELOCITY_IOD_PER_S: 0.5,
+  MOTION_TAU_S: 0.4,
+  MOTION_DEADBAND_IOD_PER_S: 0.1,
+  READY_WINDOW_MS: 500,
+  // 0.7→0.75 with the trimmed window: trimming forgives exactly ONE flaky
+  // tick; the raised mean keeps a SECOND bad tick (a real sustained wobble)
+  // from diluting through at 10 Hz cadences.
+  READY_MEAN_Q: 0.75,
+  GUIDE_SIZE: 0.6,
+  GUIDE_CENTERING: 0.6,
+  GUIDE_POSE: 0.6,
+  GUIDE_EXPOSURE: 0.6,
+  GUIDE_SHARPNESS: 0.35,
+  GUIDE_MOTION: 0.5
+});
+var clamp01 = (value) => Math.min(1, Math.max(0, value));
+var FaceGateV3 = class {
+  constructor(overrides = {}) {
+    this.p = 0;
+    this.lastTickAt = null;
+    this.lastCenter = null;
+    this.velocityEma = 0;
+    this.qWindow = [];
+    /** Which side of the ideal band the last size measurement fell on. */
+    this.lastSizeDirection = "ideal";
+    this.t = { ...V3_GATE_DEFAULTS, ...overrides };
+  }
+  reset() {
+    this.p = 0;
+    this.lastTickAt = null;
+    this.lastCenter = null;
+    this.velocityEma = 0;
+    this.qWindow = [];
+    this.lastSizeDirection = "ideal";
+  }
+  tick(input) {
+    const { observation, quality, timestampMs } = input;
+    const dtSeconds = this.lastTickAt === null ? 0 : Math.max(0, (timestampMs - this.lastTickAt) / 1e3);
+    this.lastTickAt = timestampMs;
+    const factors = {
+      presence: 0,
+      centering: 0,
+      size: 0,
+      pose: 0,
+      sharpness: clamp01(quality.sharpness),
+      exposure: clamp01(quality.exposure),
+      motion: 1
+    };
+    if (observation !== null) {
+      factors.presence = 1;
+      const geometry = this.geometryOf(observation, input);
+      factors.centering = geometry.centering;
+      factors.size = geometry.size;
+      factors.pose = geometry.pose;
+      factors.motion = this.motionOf(
+        geometry.center,
+        geometry.iod,
+        timestampMs
+      );
+    } else {
+      this.lastCenter = null;
+      this.velocityEma = 0;
+    }
+    const q = Math.min(
+      factors.presence,
+      factors.centering,
+      factors.size,
+      factors.pose,
+      factors.sharpness,
+      factors.exposure,
+      factors.motion
+    );
+    this.p = clamp01(
+      this.p + (q >= this.t.Q_GOOD ? this.t.RISE_PER_S * q : -this.t.FALL_PER_S * (1 - q)) * dtSeconds
+    );
+    this.qWindow.push({ at: timestampMs, q });
+    this.qWindow = this.qWindow.filter(
+      (entry) => entry.at >= timestampMs - this.t.READY_WINDOW_MS
+    );
+    let windowSamples = this.qWindow.map((entry) => entry.q);
+    if (windowSamples.length >= 3) {
+      const worst = Math.min(...windowSamples);
+      const worstIndex = windowSamples.indexOf(worst);
+      windowSamples = windowSamples.filter((_, index) => index !== worstIndex);
+    }
+    const windowMean = windowSamples.reduce((sum, value) => sum + value, 0) / Math.max(1, windowSamples.length);
+    const ready = this.p >= 1 && windowMean >= this.t.READY_MEAN_Q;
+    return {
+      at: timestampMs,
+      q,
+      p: this.p,
+      factors,
+      guidanceKey: this.guidanceOf(factors, quality, q),
+      ready
+    };
+  }
+  geometryOf(observation, input) {
+    const { box, eyes } = observation;
+    const frameCenter = { x: input.frameWidth / 2, y: input.frameHeight / 2 };
+    const shortSide = Math.min(input.frameWidth, input.frameHeight);
+    const center = eyes !== void 0 ? {
+      x: (eyes.left.x + eyes.right.x) / 2,
+      y: (eyes.left.y + eyes.right.y) / 2
+    } : {
+      x: box.x + box.width / 2,
+      y: box.y + box.height / 2 - this.t.BOX_EYE_OFFSET_FACTOR * box.height
+    };
+    const iod = eyes !== void 0 ? Math.hypot(eyes.right.x - eyes.left.x, eyes.right.y - eyes.left.y) : this.t.IOD_BOX_PROXY_FACTOR * box.width;
+    const distance = Math.hypot(
+      center.x - frameCenter.x,
+      center.y - frameCenter.y
+    );
+    const centering = iod <= 0 ? 0 : 1 - clamp01(distance / (this.t.CENTER_FALLOFF_IOD_MULTIPLE * iod));
+    const ratio = shortSide > 0 ? iod / shortSide : 0;
+    this.lastSizeDirection = ratio < this.t.SIZE_IDEAL_MIN ? "far" : ratio > this.t.SIZE_IDEAL_MAX ? "close" : "ideal";
+    let size;
+    if (ratio < this.t.SIZE_HARD_MIN || ratio > this.t.SIZE_HARD_MAX) {
+      size = 0;
+    } else if (ratio < this.t.SIZE_IDEAL_MIN) {
+      size = (ratio - this.t.SIZE_HARD_MIN) / (this.t.SIZE_IDEAL_MIN - this.t.SIZE_HARD_MIN);
+    } else if (ratio > this.t.SIZE_IDEAL_MAX) {
+      size = (this.t.SIZE_HARD_MAX - ratio) / (this.t.SIZE_HARD_MAX - this.t.SIZE_IDEAL_MAX);
+    } else {
+      size = 1;
+    }
+    let pose = 1;
+    if (eyes !== void 0) {
+      const rollDeg = Math.abs(
+        Math.atan2(eyes.right.y - eyes.left.y, eyes.right.x - eyes.left.x)
+      ) * 180 / Math.PI;
+      pose = 1 - clamp01(rollDeg / this.t.ROLL_MAX_DEG);
+    }
+    return { center, iod, centering, size, pose };
+  }
+  motionOf(center, iod, at) {
+    const previous = this.lastCenter;
+    this.lastCenter = { ...center, at };
+    if (previous === null || iod <= 0) return 1;
+    const dtSeconds = (at - previous.at) / 1e3;
+    if (dtSeconds <= 0) return 1;
+    let velocityIodPerS = Math.hypot(center.x - previous.x, center.y - previous.y) / iod / dtSeconds;
+    if (velocityIodPerS <= this.t.MOTION_DEADBAND_IOD_PER_S)
+      velocityIodPerS = 0;
+    const alpha = 1 - Math.exp(-dtSeconds / this.t.MOTION_TAU_S);
+    this.velocityEma = alpha * velocityIodPerS + (1 - alpha) * this.velocityEma;
+    return 1 - clamp01(this.velocityEma / this.t.MOTION_VELOCITY_IOD_PER_S);
+  }
+  /** Lowest failing factor speaks — fixed priority (diagnostic, incl. light):
+   *  presence → size → centering → pose → exposure → sharpness → hold.
+   *
+   *  HONESTY FALLBACK (operator ruling 2026-07-12): when every factor clears
+   *  its guide threshold but q (= min factor) is still below Q_GOOD — i.e.
+   *  progress is DRAINING — "hold still" would be a lie ("Perfect" while
+   *  nothing advances; the field symptom was users discovering by accident
+   *  that only leaning in fires the gate). In that state the WORST factor
+   *  speaks even though it passed its guide level, so the user always hears
+   *  the change that actually unblocks recording. */
+  guidanceOf(factors, quality, q) {
+    if (factors.presence <= 0) return "fcv3.no_face";
+    if (factors.size < this.t.GUIDE_SIZE) return this.sizeGuidance();
+    if (factors.centering < this.t.GUIDE_CENTERING) return "fcv3.center_face";
+    if (factors.pose < this.t.GUIDE_POSE) return "fcv3.straighten";
+    if (factors.exposure < this.t.GUIDE_EXPOSURE)
+      return this.exposureGuidance(quality);
+    if (factors.sharpness < this.t.GUIDE_SHARPNESS) return "fcv3.steady_camera";
+    if (factors.motion < this.t.GUIDE_MOTION) return "fcv3.hold_still";
+    if (q < this.t.Q_GOOD) {
+      const coachable = [
+        ["size", this.sizeGuidance()],
+        ["centering", "fcv3.center_face"],
+        ["pose", "fcv3.straighten"],
+        ["exposure", this.exposureGuidance(quality)],
+        ["sharpness", "fcv3.steady_camera"],
+        ["motion", "fcv3.hold_still"]
+      ];
+      let worst = coachable[0];
+      for (const entry of coachable) {
+        if (factors[entry[0]] < factors[worst[0]]) worst = entry;
+      }
+      return worst[1];
+    }
+    return "fcv3.hold_still";
+  }
+  /** Direction from the size band set THIS tick (never inverted at the hard
+   *  limits: past SIZE_HARD_MAX the direction is 'close' → move_back). */
+  sizeGuidance() {
+    return this.lastSizeDirection === "far" ? "fcv3.come_closer" : "fcv3.move_back";
+  }
+  /** Band midpoint — direction only (tracks EXPOSURE_BAND automatically). */
+  exposureGuidance(quality) {
+    const bandMid = (EXPOSURE_BAND[0] + EXPOSURE_BAND[1]) / 2;
+    return quality.meanLuma < bandMid ? "fcv3.more_light" : "fcv3.too_bright";
+  }
+};
+
+// src/core/v3/capture-session-v3.ts
+var KEYFRAME_CANDIDATES = 4;
+var KEYFRAME_WINDOW_MS = 600;
+var NEUTRAL_QUALITY = { sharpness: 1, exposure: 1, meanLuma: 128 };
+var CaptureSessionV3 = class {
+  constructor(options) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.stateValue = "idle";
+    this.attempt = 0;
+    this.stream = null;
+    this.detector = null;
+    this.scheduler = null;
+    this.gate = null;
+    this.profiler = null;
+    this.lastGuidanceKey = null;
+    this.positioningStartedAt = 0;
+    this.fired = false;
+    this.carriedDegrade = 0;
+    this.carriedMeans = [];
+    /** Reused downscale canvas — falls back to the raw video where canvas 2D
+     *  is unavailable (jsdom) so tests and exotic hosts keep detecting. */
+    this.snapshotCanvas = null;
+    this.options = options;
+    this.facing = options.facingMode ?? "user";
+  }
+  get state() {
+    return this.stateValue;
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => set?.delete(handler);
+  }
+  emit(event, payload) {
+    for (const handler of [...this.handlers.get(event) ?? []]) {
+      handler(payload);
+    }
+  }
+  async start() {
+    this.attempt += 1;
+    await this.run(this.attempt);
+  }
+  /** Full reset + camera restart — the documented recovery path (v1 parity). */
+  retry() {
+    this.teardownAttempt();
+    void this.start();
+  }
+  switchCamera() {
+    this.facing = this.facing === "user" ? "environment" : "user";
+    this.teardownAttempt();
+    void this.start();
+  }
+  destroy() {
+    this.attempt += 1;
+    this.teardownAttempt();
+    this.detector?.destroy();
+    this.detector = null;
+    this.options.video.srcObject = null;
+  }
+  // ── attempt lifecycle ──────────────────────────────────────────────────────
+  async run(attempt) {
+    const { options } = this;
+    this.fired = false;
+    this.lastGuidanceKey = null;
+    this.carriedDegrade = 0;
+    this.carriedMeans = [];
+    this.setState("preflight");
+    const preflight = cameraPreflight();
+    if (preflight !== "OK") {
+      this.fail(preflight === "INSECURE_CONTEXT" ? "insecure" : "unsupported");
+      return;
+    }
+    this.setState("acquiring");
+    const getUserMedia = options.getUserMedia ?? ((constraints) => navigator.mediaDevices.getUserMedia(constraints));
+    let stream;
+    try {
+      stream = await getUserMedia(buildCaptureConstraints(detectIsMobile(), this.facing));
+    } catch (err) {
+      if (attempt !== this.attempt) return;
+      this.fail(mapGetUserMediaError(err));
+      return;
+    }
+    if (attempt !== this.attempt) {
+      for (const track of stream.getTracks()) track.stop();
+      return;
+    }
+    this.stream = stream;
+    options.video.srcObject = stream;
+    await options.video.play().catch(() => void 0);
+    if (attempt !== this.attempt) return;
+    if (this.detector === null) {
+      const ladderOptions = {
+        ...options.v3AssetBaseUrl !== void 0 ? { v3AssetBaseUrl: options.v3AssetBaseUrl } : {}
+      };
+      const create = options.createDetector ?? (options.createWorker !== void 0 && workerOffloadSupported() ? async () => {
+        try {
+          return await WorkerDetectorProxy.create(
+            options.createWorker(),
+            ladderOptions
+          );
+        } catch {
+          return createDetector(ladderOptions);
+        }
+      } : () => createDetector(ladderOptions));
+      let created;
+      try {
+        created = await create();
+      } catch (err) {
+        if (attempt === this.attempt) {
+          this.fail(
+            "models",
+            err instanceof DetectorLadderError ? err.fallbackReason : describeError2(err)
+          );
+        }
+        return;
+      }
+      if (attempt !== this.attempt) {
+        created.destroy();
+        return;
+      }
+      this.detector = created;
+      this.options.telemetry?.({
+        type: "detector",
+        tier: created.tier,
+        ...created.fallbackReason !== void 0 ? { fallbackReason: created.fallbackReason } : {}
+      });
+    }
+    const probe = probeDevice();
+    const staticClass = options.deviceClass ?? classifyDevice(probe);
+    this.profiler = new DeviceProfiler(staticClass);
+    this.options.telemetry?.({
+      type: "profile",
+      staticClass,
+      activeClass: this.profiler.deviceClass,
+      simd: probe.simd
+    });
+    this.gate = new FaceGateV3(options.thresholds ?? {});
+    this.setState("positioning");
+    this.positioningStartedAt = this.now();
+    this.startScheduler(attempt);
+  }
+  /** Chrome hint (Task 11): 'reduced' on LOW even without the media query. */
+  get animations() {
+    return this.profiler?.profile.animations ?? "full";
+  }
+  startScheduler(attempt) {
+    const profiler = this.profiler;
+    if (profiler === null) return;
+    if (this.scheduler !== null) {
+      const stats = this.scheduler.stats();
+      this.carriedDegrade += stats.degradeCount;
+      if (stats.meanDetectMs > 0) this.carriedMeans.push(stats.meanDetectMs);
+      this.scheduler.stop();
+    }
+    const scheduler = new DetectScheduler({
+      cadenceHz: profiler.profile.cadenceHz,
+      video: this.options.video,
+      ...this.options.now !== void 0 ? { now: this.options.now } : {},
+      run: () => this.detectTick(attempt)
+    });
+    this.scheduler = scheduler;
+    scheduler.start();
+  }
+  async detectTick(attempt) {
+    const { detector, gate, profiler } = this;
+    const video = this.options.video;
+    if (attempt !== this.attempt || detector === null || gate === null || profiler === null)
+      return;
+    if (this.fired || video.videoWidth === 0) return;
+    const before = profiler.deviceClass;
+    const t0 = this.now();
+    const source = this.options.makeSnapshot?.(video, profiler.profile.inputWidth) ?? this.defaultSnapshot(video, profiler.profile.inputWidth);
+    let observation = null;
+    try {
+      observation = await detector.detect(source, video.videoWidth, video.videoHeight);
+    } catch {
+      observation = null;
+    }
+    if (attempt !== this.attempt || this.fired) return;
+    profiler.record(this.now() - t0);
+    if (profiler.deviceClass !== before) this.startScheduler(attempt);
+    const quality = observation === null ? NEUTRAL_QUALITY : this.options.measureQuality?.(video, observation.box) ?? this.defaultQuality(video, observation.box);
+    const tick = gate.tick({
+      timestampMs: this.now(),
+      observation,
+      quality,
+      frameWidth: video.videoWidth,
+      frameHeight: video.videoHeight
+    });
+    this.emit("checks", {
+      engine: "v3",
+      progress: tick.p,
+      q: tick.q,
+      factors: tick.factors,
+      attempt
+    });
+    if (tick.guidanceKey !== this.lastGuidanceKey) {
+      this.lastGuidanceKey = tick.guidanceKey;
+      this.emit("guidance", { key: tick.guidanceKey });
+    }
+    if (tick.ready && this.stateValue === "positioning") {
+      this.fired = true;
+      void this.fire(attempt);
+    }
+  }
+  async fire(attempt) {
+    const { options } = this;
+    const scheduler = this.scheduler;
+    scheduler?.stop();
+    const stats = scheduler?.stats() ?? { degradeCount: 0, meanDetectMs: 0 };
+    const means = [...this.carriedMeans, ...stats.meanDetectMs > 0 ? [stats.meanDetectMs] : []];
+    options.telemetry?.({
+      type: "fired",
+      timeToGateMs: this.now() - this.positioningStartedAt,
+      degradeCount: this.carriedDegrade + stats.degradeCount,
+      meanDetectMs: means.length === 0 ? 0 : means.reduce((sum, value) => sum + value, 0) / means.length
+    });
+    const mode = options.mode ?? "clip";
+    const bestOf = this.collectKeyframes(attempt);
+    if (mode === "photo") {
+      const best2 = await bestOf;
+      if (attempt !== this.attempt) return;
+      if (best2 === null) {
+        this.fail("generic");
+        return;
+      }
+      this.finishCapture({ keyframe: best2.blob, previewDataUrl: best2.previewDataUrl });
+      return;
+    }
+    this.setState("recording");
+    const recorder = options.createRecorder?.() ?? new ClipRecorder();
+    const stream = this.stream;
+    if (stream === null) {
+      this.fail("generic");
+      return;
+    }
+    let frozenBest = null;
+    void bestOf.then(
+      (candidate) => {
+        frozenBest = candidate;
+      },
+      () => {
+      }
+    );
+    const onRecordingStopped = () => {
+      if (attempt !== this.attempt) return;
+      if (frozenBest !== null) {
+        this.emit("frozen", { previewDataUrl: frozenBest.previewDataUrl });
+      }
+    };
+    let clip;
+    let best;
+    try {
+      [clip, best] = await Promise.all([recorder.record(stream, onRecordingStopped), bestOf]);
+    } catch (err) {
+      if (attempt !== this.attempt) return;
+      const kind = err.kind;
+      this.fail(kind === "cliptoolarge" ? "cliptoolarge" : "recorder");
+      return;
+    }
+    if (attempt !== this.attempt) return;
+    if (isClipTooLarge(clip.blob)) {
+      this.fail("cliptoolarge");
+      return;
+    }
+    if (best === null) {
+      this.fail("generic");
+      return;
+    }
+    this.finishCapture({
+      clip: clip.blob,
+      clipMimeType: clip.mimeType,
+      keyframe: best.blob,
+      previewDataUrl: best.previewDataUrl
+    });
+  }
+  /** Up to KEYFRAME_CANDIDATES mirrored frames over KEYFRAME_WINDOW_MS —
+   *  sharpest wins (reuses frame-quality.sharpness via the capture seam). */
+  async collectKeyframes(attempt) {
+    const capture = this.options.captureKeyframe ?? ((video) => this.defaultKeyframe(video));
+    const stepMs = KEYFRAME_WINDOW_MS / (KEYFRAME_CANDIDATES - 1);
+    let best = null;
+    for (let i = 0; i < KEYFRAME_CANDIDATES; i += 1) {
+      if (attempt !== this.attempt) return best;
+      try {
+        const candidate = await capture(this.options.video);
+        if (best === null || candidate.sharpness > best.sharpness) best = candidate;
+      } catch {
+      }
+      if (i < KEYFRAME_CANDIDATES - 1) await delay(stepMs);
+    }
+    return best;
+  }
+  finishCapture(artifacts) {
+    this.stopTracks();
+    this.setState("captured");
+    this.emit("artifacts", artifacts);
+  }
+  // ── defaults for the canvas-bound seams ────────────────────────────────────
+  async defaultKeyframe(video) {
+    const canvas = document.createElement("canvas");
+    const blob = await captureMirroredKeyframe(video, canvas);
+    const previewDataUrl = canvas.toDataURL("image/jpeg", 0.92);
+    return { blob, previewDataUrl, sharpness: this.centerSharpness(video) };
+  }
+  defaultSnapshot(video, targetWidth) {
+    try {
+      const canvas = this.snapshotCanvas ?? document.createElement("canvas");
+      const scale = targetWidth / Math.max(1, video.videoWidth);
+      const width = Math.max(1, Math.round(video.videoWidth * scale));
+      const height = Math.max(1, Math.round(video.videoHeight * scale));
+      const ctx = canvas.getContext("2d");
+      if (ctx === null) return video;
+      if (canvas.width !== width) canvas.width = width;
+      if (canvas.height !== height) canvas.height = height;
+      ctx.drawImage(video, 0, 0, width, height);
+      this.snapshotCanvas = canvas;
+      return canvas;
+    } catch {
+      return video;
+    }
+  }
+  defaultQuality(video, box) {
+    const crop = cropImageData(video, box, 96);
+    if (crop === null) return NEUTRAL_QUALITY;
+    return { sharpness: sharpness(crop), exposure: exposure(crop), meanLuma: meanLuma(crop) };
+  }
+  centerSharpness(video) {
+    const size = intrinsicSize(video);
+    const crop = cropImageData(
+      video,
+      { x: size.width * 0.25, y: size.height * 0.25, width: size.width * 0.5, height: size.height * 0.5 },
+      96
+    );
+    return crop === null ? 0 : sharpness(crop);
+  }
+  // ── teardown ──────────────────────────────────────────────────────────────
+  teardownAttempt() {
+    this.scheduler?.stop();
+    this.scheduler = null;
+    this.gate = null;
+    this.stopTracks();
+  }
+  stopTracks() {
+    if (this.stream === null) return;
+    for (const track of this.stream.getTracks()) track.stop();
+    this.stream = null;
+  }
+  fail(kind, fallbackReason) {
+    this.scheduler?.stop();
+    this.stopTracks();
+    this.setState("error");
+    this.options.telemetry?.({
+      type: "error",
+      kind,
+      ...fallbackReason !== void 0 ? { fallbackReason } : {}
+    });
+    this.emit("error", { kind, retryable: kind !== "insecure" && kind !== "unsupported" });
+  }
+  setState(state) {
+    this.stateValue = state;
+    this.emit("statechange", { state });
+  }
+  now() {
+    return this.options.now?.() ?? performance.now();
+  }
+};
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function describeError2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function cropImageData(video, box, targetWidth) {
+  try {
+    const canvas = document.createElement("canvas");
+    const scale = targetWidth / Math.max(1, box.width);
+    canvas.width = Math.max(1, Math.round(box.width * scale));
+    canvas.height = Math.max(1, Math.round(box.height * scale));
+    const ctx = canvas.getContext("2d");
+    if (ctx === null) return null;
+    ctx.drawImage(
+      video,
+      box.x,
+      box.y,
+      box.width,
+      box.height,
+      0,
+      0,
+      canvas.width,
+      canvas.height
+    );
+    return ctx.getImageData(0, 0, canvas.width, canvas.height);
+  } catch {
+    return null;
+  }
+}
+
+// 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/client/errors.ts
+var KNOWN_CODES = [
+  // auth / addressing (session-token.guard, controllers' own-session guards)
+  "session_token_invalid",
+  // 401 — missing/invalid/expired/revoked token
+  "session_token_required",
+  // 403 — non-session-token principal on a hosted route (defensive)
+  "session_token_session_mismatch",
+  // 403 — route :id differs from the token's bound session
+  "session_not_found",
+  // 404 — token's session missing/foreign (findOwned)
+  // rate limiting (session-token.guard — per-token + per-IP buckets)
+  "rate_limit_exceeded",
+  // 429 + Retry-After header (seconds)
+  // consent gate (Task 0 — submit AND media presign/complete)
+  "consent_required",
+  // 409 — record consent before uploading/submitting
+  // submit flow (sessions.service.submitCheck)
+  "session_not_active",
+  // 409 — session is terminal/review; no further submissions
+  "check_not_found",
+  // 404 — session has no such checkType
+  "check_already_finalized",
+  // 409 — re-submit of a terminal/review check
+  "check_out_of_order",
+  // 409 — only the frontier check accepts a submission
+  "check_type_unsupported",
+  // 400 — no registered executor for the checkType
+  "force_outcome_forbidden",
+  // 403 — forceOutcome on a live session (plan D-C)
+  "attestation_invalid",
+  // 400 (Task 1) — Turnstile/attestation failed; reload and retry
+  "nni_locked",
+  // 409 (Plan A Task 2) — session is bound to a server-provided NNI; a different client NNI was sent
+  // media (media.service)
+  "media_content_type_not_allowed",
+  // 400 — outside the per-kind MIME allowlist
+  "media_too_large",
+  // 413 — over the per-kind byte cap
+  "media_key_invalid",
+  // 400 — not a well-formed pending key
+  "media_key_forbidden",
+  // 403 — key names another session's pending space
+  "media_not_found",
+  // 404 — no uploaded object behind the key
+  "media_unreadable",
+  // 422 — magic-byte sniff rejected the object
+  "media_session_invalid",
+  // 400 — sessionId unusable as a key segment (never in practice)
+  // idempotency (idempotency.interceptor — Task 2)
+  "idempotency_key_collision",
+  // 409 — same key, different body hash
+  "idempotency_in_progress",
+  // 409 — concurrent identical request mid-flight (client auto-retries)
+  "idempotency_key_required",
+  // 400 — only on @Idempotent({required:true}) routes (none hosted yet)
+  // validation + fallback
+  "validation_error",
+  // 400 — ValibotPipe rejection (camelToSnake of 'ValidationError')
+  "internal_error",
+  // 500 — unhandled server error
+  // client-synthesized (never sent by the backend)
+  "unknown_error",
+  // unparseable (non-JSON) response body — error OR 2xx (defensive)
+  "upload_failed",
+  // the bare Spaces PUT answered non-2xx
+  "network_error",
+  // fetch rejected: connection drop / DNS / CORS / mid-transfer (status 0)
+  "timeout"
+  // AbortSignal.timeout fired — API calls 30 s default, Spaces PUT 15 min (status 0)
+];
+function isKnownCode(code) {
+  return KNOWN_CODES.includes(code);
+}
+var HostedApiError = class extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "HostedApiError";
+    this.status = args.status;
+    this.code = args.code;
+    if (args.retryAfterSeconds !== void 0) this.retryAfterSeconds = args.retryAfterSeconds;
+  }
+};
+
+// src/client/hosted-client.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SPACES_PUT_TIMEOUT_MS = 9e5;
+var UPLOAD_ERROR_SNIPPET_CHARS = 200;
+var IN_PROGRESS_RETRY_ATTEMPTS = 5;
+var IN_PROGRESS_RETRY_DELAY_MS = 400;
+function stripMimeParams(contentType) {
+  return (contentType.split(";")[0] ?? "").trim();
+}
+var MEDIA_INPUT_FIELD = {
+  liveness: "clipKey",
+  face_match: "imageKey",
+  doc_ocr: "imageKey"
+};
+var HostedClient = class {
+  constructor(opts) {
+    this.sessionId = null;
+    this.bootstrap = null;
+    this.apiOrigin = opts.apiOrigin.replace(/\/+$/, "");
+    this.sessionToken = opts.sessionToken;
+    const impl = opts.fetch;
+    this.fetchImpl = (input, init) => (impl ?? globalThis.fetch).call(globalThis, input, init);
+    this.requestTimeoutMs = opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.retryAttempts = opts.inProgressRetry?.attempts ?? IN_PROGRESS_RETRY_ATTEMPTS;
+    this.retryDelayMs = opts.inProgressRetry?.delayMs ?? IN_PROGRESS_RETRY_DELAY_MS;
+  }
+  /** Token-addressed bootstrap — the hosted page's first call. Caches the sessionId. */
+  async getSession() {
+    const view = await this.api("GET", "/hosted/session");
+    this.sessionId = view.sessionId;
+    return view;
+  }
+  /**
+   * Record consent once (201; an idempotent replay answers 200 with
+   * `alreadyRecorded: true`). Until recorded, media presign/complete AND check
+   * submission answer 409 `consent_required`.
+   */
+  async recordConsent(locale) {
+    return this.api("POST", "/hosted/consent", { body: { locale } });
+  }
+  /**
+   * Presign a Spaces PUT for a new pending object. `contentType` is stripped of
+   * MIME parameters defensively (the allowlist holds bare types; the engine's
+   * `clipMimeType` carries codec params) — PUT with the SAME bare type, or the
+   * signed-header check rejects the upload.
+   */
+  async presign(kind, contentType, contentLength) {
+    const id = await this.ensureSessionId();
+    const body = { kind, contentType: stripMimeParams(contentType), contentLength };
+    return this.api("POST", `/sessions/${id}/media`, { body });
+  }
+  /**
+   * Bare PUT to the presigned Spaces URL: EXACTLY the signed headers — the
+   * declared Content-Type and the blob body. NO `x-session-token` (the
+   * signature IS the credential; an extra header breaks nothing but leaks the
+   * token to a third-party host) and no JSON envelope.
+   *
+   * `contentType` is param-stripped here too (idempotent for bare types): the
+   * presign strips internally, so a caller composing manually with the engine's
+   * parameterful `clipMimeType` would otherwise sign `video/webm` but PUT
+   * `video/webm;codecs=…` — a signed-header mismatch S3 rejects at runtime.
+   *
+   * Timeout: 15 min (`AbortSignal.timeout(900_000)`, matching the presign TTL)
+   * rather than the API calls' 30 s — a 15 MB clip on a slow link legitimately
+   * exceeds 30 s, but a stalled in-flight socket must still be bounded (the TTL
+   * alone only bounds when a PUT can START).
+   *
+   * Failures are ALWAYS typed: non-2xx throws {@link HostedApiError} with the
+   * client-synthesized `upload_failed` (message carries a truncated S3 body
+   * snippet — e.g. SignatureDoesNotMatch); a mid-transfer drop → `network_error`;
+   * the timeout → `timeout`.
+   */
+  async uploadToSpaces(uploadUrl, blob, contentType) {
+    let res;
+    try {
+      res = await this.fetchImpl(uploadUrl, {
+        method: "PUT",
+        headers: { "content-type": stripMimeParams(contentType) },
+        body: blob,
+        signal: AbortSignal.timeout(SPACES_PUT_TIMEOUT_MS)
+      });
+    } catch (err) {
+      throw asTransportError(err);
+    }
+    if (!res.ok) {
+      const snippet = (await res.text().catch(() => "")).slice(0, UPLOAD_ERROR_SNIPPET_CHARS);
+      throw new HostedApiError({
+        status: res.status,
+        code: "upload_failed",
+        message: `media upload failed (HTTP ${res.status})${snippet ? `: ${snippet}` : ""}`
+      });
+    }
+  }
+  /** Finalize an upload: the backend sniffs + promotes; returns the PROMOTED key to submit. */
+  async completeMedia(key) {
+    const id = await this.ensureSessionId();
+    return this.api("POST", `/sessions/${id}/media/complete`, {
+      body: { key }
+    });
+  }
+  /**
+   * Submit one check. Sends `{input, forceOutcome?}` (SubmitCheckSchema) and the
+   * optional `x-idempotency-key` header. Returns the whitelisted SessionView.
+   */
+  async submitCheck(checkType, input, opts = {}) {
+    const id = await this.ensureSessionId();
+    const body = {
+      input,
+      ...opts.forceOutcome !== void 0 ? { forceOutcome: opts.forceOutcome } : {}
+    };
+    return this.api("POST", `/sessions/${id}/checks/${checkType}`, {
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {}
+    });
+  }
+  /**
+   * Convenience composition: presign → PUT → complete → submit, passing the
+   * PROMOTED key (from complete's response — never the pending presign key)
+   * into the check's media input field (`clipKey` for liveness, `imageKey` for
+   * face_match/doc_ocr). `extraInput` carries the remaining input fields
+   * (liveness `attestation`, doc_ocr `side`). The media content type is
+   * param-stripped ONCE and used for both presign and PUT, so the signed
+   * header always matches.
+   */
+  async uploadAndSubmit(checkType, media, extraInput, opts = {}) {
+    const bareType = stripMimeParams(media.contentType);
+    const presigned = await this.presign(media.kind, bareType, media.blob.size);
+    await this.uploadToSpaces(presigned.uploadUrl, media.blob, bareType);
+    const completed = await this.completeMedia(presigned.key);
+    const input = {
+      ...extraInput,
+      [MEDIA_INPUT_FIELD[checkType]]: completed.key
+    };
+    return this.submitCheck(checkType, input, opts);
+  }
+  // ── transport ──────────────────────────────────────────────────────────────
+  /** The token's own sessionId — cached from getSession(), lazily bootstrapped. */
+  async ensureSessionId() {
+    if (this.sessionId !== null) return this.sessionId;
+    this.bootstrap ?? (this.bootstrap = this.getSession().finally(() => {
+      this.bootstrap = null;
+    }));
+    return (await this.bootstrap).sessionId;
+  }
+  /**
+   * One API request: `${apiOrigin}/api/v2${path}`, `x-session-token` always,
+   * AbortSignal timeout (30 s default), `{success, data}` unwrap on 2xx, flat
+   * `{code, message}` → {@link HostedApiError} on non-2xx. EVERY failure is
+   * typed: a rejected fetch → `network_error`, the timeout → `timeout`, an
+   * unparseable 2xx body → `unknown_error` — the page never sees a raw
+   * TypeError/DOMException. The ONLY automatic retry is 409
+   * `idempotency_in_progress` (bounded, short delay).
+   */
+  async api(method, path, opts = {}) {
+    const url = `${this.apiOrigin}/api/v2${path}`;
+    const headers = { "x-session-token": this.sessionToken };
+    if (opts.body !== void 0) headers["content-type"] = "application/json";
+    if (opts.idempotencyKey !== void 0) headers["x-idempotency-key"] = opts.idempotencyKey;
+    for (let attempt = 0; ; attempt++) {
+      let res;
+      try {
+        res = await this.fetchImpl(url, {
+          method,
+          headers,
+          ...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {},
+          signal: AbortSignal.timeout(this.requestTimeoutMs)
+        });
+      } catch (err2) {
+        throw asTransportError(err2);
+      }
+      if (res.ok) {
+        let raw;
+        try {
+          raw = await res.json();
+        } catch {
+          throw new HostedApiError({
+            status: res.status,
+            code: "unknown_error",
+            message: `response body was not valid JSON (HTTP ${res.status})`
+          });
+        }
+        return unwrap(raw);
+      }
+      const err = await parseErrorResponse(res);
+      if (err.code === "idempotency_in_progress" && attempt < this.retryAttempts) {
+        if (this.retryDelayMs > 0) await sleep(this.retryDelayMs);
+        continue;
+      }
+      throw err;
+    }
+  }
+};
+function asTransportError(err) {
+  const name = typeof err === "object" && err !== null ? err.name : void 0;
+  if (name === "TimeoutError") {
+    return new HostedApiError({ status: 0, code: "timeout", message: "request timed out" });
+  }
+  const detail = err instanceof Error ? err.message : String(err);
+  return new HostedApiError({
+    status: 0,
+    code: "network_error",
+    message: `network request failed: ${detail}`
+  });
+}
+function unwrap(raw) {
+  if (raw !== null && typeof raw === "object" && "success" in raw && "data" in raw) {
+    return raw.data;
+  }
+  return raw;
+}
+async function parseErrorResponse(res) {
+  let code = "unknown_error";
+  let message = `request failed (HTTP ${res.status})`;
+  try {
+    const body = await res.json();
+    if (body !== null && typeof body === "object") {
+      const env = body;
+      if (typeof env.code === "string" && env.code.length > 0) code = env.code;
+      if (typeof env.message === "string" && env.message.length > 0) message = env.message;
+    }
+  } catch {
+  }
+  const retryAfterRaw = res.headers.get("retry-after");
+  const retryAfter = retryAfterRaw === null ? Number.NaN : Number.parseInt(retryAfterRaw, 10);
+  return new HostedApiError({
+    status: res.status,
+    code,
+    message,
+    ...Number.isFinite(retryAfter) && retryAfter >= 0 ? { retryAfterSeconds: retryAfter } : {}
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// 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 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 sleep2 = 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: sleep2,
+    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 sleep2(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 sleep2(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();
+    }
+  };
+}
+
+// src/popup/index.ts
+var SEKYRO_EVENTS = [
+  "session.completed",
+  "session.failed",
+  "session.review_pending",
+  "session.expired",
+  "session.cancelled"
+];
+var WINDOW_NAME = "sekyro-verify";
+var WINDOW_FEATURES = "width=480,height=720,noopener=false";
+var EVENT_NAMES = new Set(SEKYRO_EVENTS);
+function isSekyroEvent(data) {
+  if (data === null || typeof data !== "object") return false;
+  const d = data;
+  return d.source === "sekyro" && d.version === 1 && typeof d.sessionId === "string" && typeof d.event === "string" && EVENT_NAMES.has(d.event);
+}
+function open(opts) {
+  const origin = new URL(opts.hostedUrl).origin;
+  const popup = window.open(opts.hostedUrl, WINDOW_NAME, WINDOW_FEATURES);
+  if (!popup) return { error: "popup_blocked" };
+  const listener = (ev) => {
+    if (ev.source !== popup) return;
+    if (ev.origin !== origin) return;
+    if (!isSekyroEvent(ev.data)) return;
+    const { source, version, event, sessionId } = ev.data;
+    opts.onEvent({ source, version, event, sessionId });
+  };
+  window.addEventListener("message", listener);
+  return {
+    close() {
+      window.removeEventListener("message", listener);
+      popup.close();
+    }
+  };
+}
+function openHosted(hostedUrl, opts) {
+  if (opts.mode === "redirect") {
+    window.location.assign(hostedUrl);
+    return { close() {
+    } };
+  }
+  return open({ hostedUrl, onEvent: opts.onEvent ?? (() => void 0) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_ORIGIN,
+  HostedApiError,
+  KNOWN_CODES,
+  SEKYRO_EVENTS,
+  createLivenessCapture,
+  createVerification,
+  isKnownCode,
+  openHosted
+});
+//# sourceMappingURL=index.cjs.map