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

package/dist/chunk-LOTAJDRE.js

@@ -0,0 +1,1094 @@
+import {
+  DetectorLadderError,
+  WorkerDetectorProxy,
+  createDetector,
+  intrinsicSize,
+  workerOffloadSupported
+} from "./chunk-NWF46H7K.js";
+import {
+  EXPOSURE_BAND,
+  exposure,
+  meanLuma,
+  sharpness
+} from "./chunk-MWNFSNMP.js";
+
+// 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/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/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/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/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 : describeError(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 describeError(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;
+  }
+}
+
+export {
+  buildCaptureConstraints,
+  detectIsMobile,
+  CIRCLE_RADIUS_FACTOR,
+  IN_CIRCLE_FACTOR,
+  CENTERED_FACTOR,
+  MIME_CANDIDATES,
+  pickMimeType,
+  DEFAULT_CLIP_MIME,
+  mapGetUserMediaError,
+  cameraPreflight,
+  isMediaRecorderSupported,
+  MAX_CLIP_BYTES,
+  isClipTooLarge,
+  extForMime,
+  buildLivenessV2FormData,
+  CLIP_MS,
+  TIMESLICE_MS,
+  STOP_GRACE_MS,
+  VIDEO_BPS,
+  ClipError,
+  ClipRecorder,
+  captureMirroredKeyframe,
+  DEVICE_PROFILES,
+  probeDevice,
+  classifyDevice,
+  DeviceProfiler,
+  DetectScheduler,
+  V3_GATE_DEFAULTS,
+  FaceGateV3,
+  KEYFRAME_CANDIDATES,
+  KEYFRAME_WINDOW_MS,
+  CaptureSessionV3
+};
+//# sourceMappingURL=chunk-LOTAJDRE.js.map