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

package/dist/core/index.cjs

@@ -0,0 +1,1605 @@
+"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/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  CENTERED_FACTOR: () => CENTERED_FACTOR,
+  CIRCLE_RADIUS_FACTOR: () => CIRCLE_RADIUS_FACTOR,
+  CLIP_MS: () => CLIP_MS,
+  CaptureSessionV3: () => CaptureSessionV3,
+  ClipError: () => ClipError,
+  ClipRecorder: () => ClipRecorder,
+  DEFAULT_CLIP_MIME: () => DEFAULT_CLIP_MIME,
+  DEFAULT_TIER_ORDER: () => DEFAULT_TIER_ORDER,
+  DEFAULT_V3_ASSET_BASE_URL: () => DEFAULT_V3_ASSET_BASE_URL,
+  DEVICE_PROFILES: () => DEVICE_PROFILES,
+  DetectScheduler: () => DetectScheduler,
+  DetectorLadderError: () => DetectorLadderError,
+  DeviceProfiler: () => DeviceProfiler,
+  EXPOSURE_BAND: () => EXPOSURE_BAND,
+  FaceGateV3: () => FaceGateV3,
+  IN_CIRCLE_FACTOR: () => IN_CIRCLE_FACTOR,
+  KEYFRAME_CANDIDATES: () => KEYFRAME_CANDIDATES,
+  KEYFRAME_WINDOW_MS: () => KEYFRAME_WINDOW_MS,
+  MAX_CLIP_BYTES: () => MAX_CLIP_BYTES,
+  MIME_CANDIDATES: () => MIME_CANDIDATES,
+  SHARP_REF: () => SHARP_REF,
+  STOP_GRACE_MS: () => STOP_GRACE_MS,
+  TIMESLICE_MS: () => TIMESLICE_MS,
+  V3_GATE_DEFAULTS: () => V3_GATE_DEFAULTS,
+  VIDEO_BPS: () => VIDEO_BPS,
+  buildCaptureConstraints: () => buildCaptureConstraints,
+  buildLivenessV2FormData: () => buildLivenessV2FormData,
+  cameraPreflight: () => cameraPreflight,
+  captureMirroredKeyframe: () => captureMirroredKeyframe,
+  classifyDevice: () => classifyDevice,
+  createDetector: () => createDetector,
+  detectIsMobile: () => detectIsMobile,
+  errorCopy: () => errorCopy,
+  exposure: () => exposure,
+  extForMime: () => extForMime,
+  intrinsicSize: () => intrinsicSize,
+  isClipTooLarge: () => isClipTooLarge,
+  isMediaRecorderSupported: () => isMediaRecorderSupported,
+  mapGetUserMediaError: () => mapGetUserMediaError,
+  meanLuma: () => meanLuma,
+  pickMimeType: () => pickMimeType,
+  probeDevice: () => probeDevice,
+  sharpness: () => sharpness,
+  toStreamPixels: () => toStreamPixels,
+  uiCopy: () => uiCopy
+});
+module.exports = __toCommonJS(core_exports);
+
+// 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;
+}
+function extForMime(mime) {
+  const m = (mime || "").toLowerCase();
+  if (m.startsWith("image/jpeg")) return "jpg";
+  if (m.startsWith("video/mp4")) return "mp4";
+  if (m.startsWith("video/webm")) return "webm";
+  return "webm";
+}
+function buildLivenessV2FormData(args) {
+  const { token, clip, keyframe } = args;
+  const ts = args.ts ?? Date.now();
+  const clipType = clip.type || DEFAULT_CLIP_MIME;
+  const kfType = keyframe.type || "image/jpeg";
+  const fd = new FormData();
+  fd.append("token", token);
+  fd.append("clip", new File([clip], `liveness-${ts}.${extForMime(clipType)}`, { type: clipType }));
+  fd.append("keyframe", new File([keyframe], `keyframe-${ts}.${extForMime(kfType)}`, { type: kfType }));
+  return fd;
+}
+
+// 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/messages.ts
+var errorCopy = {
+  permission: {
+    key: "fcv2.err.permission",
+    fr: "Autorisez la cam\xE9ra dans les r\xE9glages du navigateur (ic\xF4ne cam\xE9ra dans la barre d\u2019adresse), puis r\xE9essayez."
+  },
+  notfound: {
+    key: "fcv2.err.notfound",
+    fr: "Aucune cam\xE9ra d\xE9tect\xE9e. Branchez ou activez une cam\xE9ra, puis r\xE9essayez."
+  },
+  inuse: {
+    key: "fcv2.err.inuse",
+    fr: "La cam\xE9ra est utilis\xE9e par une autre application. Fermez-la puis r\xE9essayez."
+  },
+  overconstrained: {
+    key: "fcv2.err.overconstrained",
+    fr: "La cam\xE9ra ne prend pas en charge les r\xE9glages demand\xE9s. Nouvel essai en cours\u2026"
+  },
+  insecure: {
+    key: "fcv2.err.insecure",
+    fr: "La cam\xE9ra n\xE9cessite une connexion s\xE9curis\xE9e (HTTPS). Ouvrez la page en HTTPS."
+  },
+  unsupported: {
+    key: "fcv2.err.unsupported",
+    fr: "Votre navigateur ne prend pas en charge l\u2019enregistrement vid\xE9o. Utilisez un navigateur r\xE9cent."
+  },
+  generic: {
+    key: "fcv2.err.generic",
+    fr: "Cam\xE9ra indisponible. R\xE9essayez ou contactez le support."
+  }
+};
+var uiCopy = {
+  recording: { key: "fcv2.recording", fr: "Enregistrement en cours\u2026" },
+  uploading: { key: "fcv2.uploading", fr: "Envoi en cours\u2026" },
+  clipTooLarge: {
+    key: "fcv2.err.cliptoolarge",
+    fr: "La vid\xE9o est trop volumineuse. R\xE9essayez dans un endroit mieux \xE9clair\xE9."
+  },
+  retry: { key: "fcv2.retry", fr: "R\xE9essayer" },
+  listen: { key: "fcv2.listen", fr: "\xC9couter" }
+};
+
+// 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/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 ?? "")
+  );
+}
+var CIRCLE_RADIUS_FACTOR = 0.45;
+var IN_CIRCLE_FACTOR = 0.9;
+var CENTERED_FACTOR = 0.4;
+
+// 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/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/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/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/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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CENTERED_FACTOR,
+  CIRCLE_RADIUS_FACTOR,
+  CLIP_MS,
+  CaptureSessionV3,
+  ClipError,
+  ClipRecorder,
+  DEFAULT_CLIP_MIME,
+  DEFAULT_TIER_ORDER,
+  DEFAULT_V3_ASSET_BASE_URL,
+  DEVICE_PROFILES,
+  DetectScheduler,
+  DetectorLadderError,
+  DeviceProfiler,
+  EXPOSURE_BAND,
+  FaceGateV3,
+  IN_CIRCLE_FACTOR,
+  KEYFRAME_CANDIDATES,
+  KEYFRAME_WINDOW_MS,
+  MAX_CLIP_BYTES,
+  MIME_CANDIDATES,
+  SHARP_REF,
+  STOP_GRACE_MS,
+  TIMESLICE_MS,
+  V3_GATE_DEFAULTS,
+  VIDEO_BPS,
+  buildCaptureConstraints,
+  buildLivenessV2FormData,
+  cameraPreflight,
+  captureMirroredKeyframe,
+  classifyDevice,
+  createDetector,
+  detectIsMobile,
+  errorCopy,
+  exposure,
+  extForMime,
+  intrinsicSize,
+  isClipTooLarge,
+  isMediaRecorderSupported,
+  mapGetUserMediaError,
+  meanLuma,
+  pickMimeType,
+  probeDevice,
+  sharpness,
+  toStreamPixels,
+  uiCopy
+});
+//# sourceMappingURL=index.cjs.map