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

package/dist/internal/index.cjs

@@ -0,0 +1,4166 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/doc/doc-catalog.ts
+function aspectBand(format) {
+  return ASPECT_BANDS[format];
+}
+var ASPECT_BANDS, MR_DOC_CATALOG;
+var init_doc_catalog = __esm({
+  "src/core/doc/doc-catalog.ts"() {
+    "use strict";
+    ASPECT_BANDS = {
+      "ID-1": { center: 1.586, tolerance: 0.15 },
+      "ID-3": { center: 1.42, tolerance: 0.2 }
+    };
+    MR_DOC_CATALOG = [
+      {
+        docType: "carte_identite",
+        format: "ID-1",
+        sides: ["recto", "verso"],
+        mrz: "td1",
+        // verso; carries the NNI with ICAO check digits (findings §6)
+        portraitSide: "recto",
+        aspectRatio: 1.586,
+        identifierSource: "mrz"
+      },
+      {
+        docType: "passport",
+        format: "ID-3",
+        sides: ["single"],
+        mrz: "td3",
+        portraitSide: "single",
+        // data page
+        aspectRatio: 1.42,
+        identifierSource: "mrz"
+      }
+    ];
+  }
+});
+
+// src/core/v3/frame-quality.ts
+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 i2 = 0; i2 < pixels; i2 += 1) sum += lumaAt(data, i2 * 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 i2 = 0; i2 < gray.length; i2 += 1) gray[i2] = lumaAt(data, i2 * 4);
+  let sum = 0;
+  let sumSquares = 0;
+  let count = 0;
+  for (let y2 = 1; y2 < height - 1; y2 += 1) {
+    for (let x = 1; x < width - 1; x += 1) {
+      const i2 = y2 * width + x;
+      const response = (gray[i2 - width] ?? 0) + (gray[i2 - 1] ?? 0) + (gray[i2 + 1] ?? 0) + (gray[i2 + width] ?? 0) - 4 * (gray[i2] ?? 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);
+}
+var SHARP_REF, EXPOSURE_BAND, EXPOSURE_FALLOFF;
+var init_frame_quality = __esm({
+  "src/core/v3/frame-quality.ts"() {
+    "use strict";
+    SHARP_REF = 180;
+    EXPOSURE_BAND = [100, 190];
+    EXPOSURE_FALLOFF = 64;
+  }
+});
+
+// src/core/doc/doc-gate-v1.ts
+function quadAreaFrac(quad, frameWidth, frameHeight) {
+  const pts = [quad.topLeft, quad.topRight, quad.bottomRight, quad.bottomLeft];
+  let doubled = 0;
+  for (let i2 = 0; i2 < 4; i2++) {
+    const a2 = pts[i2];
+    const b = pts[(i2 + 1) % 4];
+    doubled += a2.x * b.y - b.x * a2.y;
+  }
+  const frameArea = frameWidth * frameHeight;
+  return frameArea > 0 ? Math.abs(doubled / 2) / frameArea : 0;
+}
+function quadIou(a2, b) {
+  const boxA = bbox(a2);
+  const boxB = bbox(b);
+  const x1 = Math.max(boxA.x1, boxB.x1);
+  const y1 = Math.max(boxA.y1, boxB.y1);
+  const x2 = Math.min(boxA.x2, boxB.x2);
+  const y2 = Math.min(boxA.y2, boxB.y2);
+  const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+  const areaA = (boxA.x2 - boxA.x1) * (boxA.y2 - boxA.y1);
+  const areaB = (boxB.x2 - boxB.x1) * (boxB.y2 - boxB.y1);
+  const union = areaA + areaB - inter;
+  return union > 0 ? inter / union : 0;
+}
+function quadBounds(quad) {
+  const box = bbox(quad);
+  return { width: box.x2 - box.x1, height: box.y2 - box.y1 };
+}
+function bbox(quad) {
+  const pts = [quad.topLeft, quad.topRight, quad.bottomRight, quad.bottomLeft];
+  return {
+    x1: Math.min(...pts.map((p2) => p2.x)),
+    y1: Math.min(...pts.map((p2) => p2.y)),
+    x2: Math.max(...pts.map((p2) => p2.x)),
+    y2: Math.max(...pts.map((p2) => p2.y))
+  };
+}
+function quadAspect(quad) {
+  const top = Math.hypot(quad.topRight.x - quad.topLeft.x, quad.topRight.y - quad.topLeft.y);
+  const bottom = Math.hypot(
+    quad.bottomRight.x - quad.bottomLeft.x,
+    quad.bottomRight.y - quad.bottomLeft.y
+  );
+  const left = Math.hypot(quad.bottomLeft.x - quad.topLeft.x, quad.bottomLeft.y - quad.topLeft.y);
+  const right = Math.hypot(
+    quad.bottomRight.x - quad.topRight.x,
+    quad.bottomRight.y - quad.topRight.y
+  );
+  const horizontal = (top + bottom) / 2;
+  const vertical = (left + right) / 2;
+  if (horizontal <= 0 || vertical <= 0) return 0;
+  return Math.max(horizontal, vertical) / Math.min(horizontal, vertical);
+}
+var DOC_DETECT_WIDTH, DOC_GATE_V1_DEFAULTS, clamp01, DocGateV1;
+var init_doc_gate_v1 = __esm({
+  "src/core/doc/doc-gate-v1.ts"() {
+    "use strict";
+    init_frame_quality();
+    init_doc_catalog();
+    DOC_DETECT_WIDTH = 480;
+    DOC_GATE_V1_DEFAULTS = Object.freeze({
+      MIN_AREA_FRAC: 0.15,
+      EDGE_CLIP_MARGIN_PX: 4,
+      STABLE_TICKS: 3,
+      IOU_STABLE_MIN: 0.85,
+      RISE_PER_S: 0.9,
+      FALL_PER_S: 0.25,
+      GUIDE_EXPOSURE: 0.6,
+      GUIDE_SHARPNESS: 0.35,
+      ID3_BAND_MIN_WIDTH_FRAC: 0.55,
+      ID3_BAND_ASPECT_MIN: 4,
+      ID3_BAND_ASPECT_MAX: 40
+    });
+    clamp01 = (value) => Math.min(1, Math.max(0, value));
+    DocGateV1 = class {
+      constructor(format, overrides = {}) {
+        this.p = 0;
+        this.lastTickAt = null;
+        this.lastQuad = null;
+        this.streak = 0;
+        this.format = format;
+        this.t = { ...DOC_GATE_V1_DEFAULTS, ...overrides };
+      }
+      reset() {
+        this.p = 0;
+        this.lastTickAt = null;
+        this.lastQuad = null;
+        this.streak = 0;
+      }
+      tick(input) {
+        const { quad, quality, timestampMs } = input;
+        const dtSeconds = this.lastTickAt === null ? 0 : Math.max(0, (timestampMs - this.lastTickAt) / 1e3);
+        this.lastTickAt = timestampMs;
+        let geometryKey = null;
+        if (quad === null) {
+          geometryKey = "dcv1.no_doc";
+        } else if (this.format === "ID-3") {
+          const box = quadBounds(quad);
+          const aspect = box.height > 0 ? box.width / box.height : 0;
+          if (box.width < this.t.ID3_BAND_MIN_WIDTH_FRAC * input.frameWidth) {
+            geometryKey = "dcv1.come_closer";
+          } else if (this.edgeClipped(quad, input.frameWidth, input.frameHeight)) {
+            geometryKey = "dcv1.fit_document";
+          } else if (aspect < this.t.ID3_BAND_ASPECT_MIN || aspect > this.t.ID3_BAND_ASPECT_MAX) {
+            geometryKey = "dcv1.wrong_shape";
+          }
+        } else if (quadAreaFrac(quad, input.frameWidth, input.frameHeight) < this.t.MIN_AREA_FRAC) {
+          geometryKey = "dcv1.come_closer";
+        } else if (this.edgeClipped(quad, input.frameWidth, input.frameHeight)) {
+          geometryKey = "dcv1.fit_document";
+        } else {
+          const band = aspectBand(this.format);
+          const aspect = quadAspect(quad);
+          if (Math.abs(aspect - band.center) > band.tolerance) geometryKey = "dcv1.wrong_shape";
+        }
+        const plausible = geometryKey === null;
+        const exposureOk = clamp01(quality.exposure) >= this.t.GUIDE_EXPOSURE;
+        const sharpnessOk = clamp01(quality.sharpness) >= this.t.GUIDE_SHARPNESS;
+        const qualityOk = exposureOk && sharpnessOk;
+        if (plausible && qualityOk && quad !== null) {
+          const held = this.lastQuad === null || quadIou(quad, this.lastQuad) >= this.t.IOU_STABLE_MIN;
+          this.streak = held ? this.streak + 1 : 1;
+        } else {
+          this.streak = 0;
+        }
+        this.lastQuad = quad;
+        const good = plausible && qualityOk;
+        this.p = clamp01(this.p + (good ? this.t.RISE_PER_S : -this.t.FALL_PER_S) * dtSeconds);
+        const ready = good && this.streak >= this.t.STABLE_TICKS;
+        let guidanceKey;
+        if (geometryKey !== null) {
+          guidanceKey = geometryKey;
+        } else if (!exposureOk) {
+          const bandMid = (EXPOSURE_BAND[0] + EXPOSURE_BAND[1]) / 2;
+          guidanceKey = quality.meanLuma < bandMid ? "dcv1.more_light" : "dcv1.too_bright";
+        } else if (!sharpnessOk) {
+          guidanceKey = "dcv1.steady";
+        } else {
+          guidanceKey = "dcv1.hold_still";
+        }
+        return { at: timestampMs, quad, plausible, p: this.p, guidanceKey, ready, stableTicks: this.streak };
+      }
+      edgeClipped(quad, frameWidth, frameHeight) {
+        const margin = this.t.EDGE_CLIP_MARGIN_PX;
+        const pts = [quad.topLeft, quad.topRight, quad.bottomRight, quad.bottomLeft];
+        return pts.some(
+          (p2) => p2.x <= margin || p2.y <= margin || p2.x >= frameWidth - margin || p2.y >= frameHeight - margin
+        );
+      }
+    };
+  }
+});
+
+// scanic-ml-stub:scanic-ml-stub
+var scanic_ml_stub_exports = {};
+__export(scanic_ml_stub_exports, {
+  default: () => scanic_ml_stub_default,
+  initMlDetector: () => initMlDetector
+});
+function initMlDetector() {
+  throw new Error("scanic ML detector is not vendored (classical pipeline only)");
+}
+var scanic_ml_stub_default;
+var init_scanic_ml_stub = __esm({
+  "scanic-ml-stub:scanic-ml-stub"() {
+    "use strict";
+    scanic_ml_stub_default = {};
+  }
+});
+
+// vendor/scanic/scanic.js
+function B(A2, B2 = {}) {
+  const t2 = B2.width || Math.sqrt(A2.length), i2 = B2.height || A2.length / t2, E2 = void 0 !== B2.mode ? B2.mode : 1, e2 = void 0 !== B2.method ? B2.method : 2, o2 = B2.minArea || I, n2 = t2 + 2, a2 = i2 + 2, s2 = new Int32Array(n2 * a2);
+  for (let I2 = 0; I2 < i2; I2++) for (let g2 = 0; g2 < t2; g2++) A2[I2 * t2 + g2] > 0 && (s2[(I2 + 1) * n2 + (g2 + 1)] = 1);
+  const c2 = [];
+  let r2 = 2;
+  for (let I2 = 1; I2 <= i2; I2++) for (let A3 = 1; A3 <= t2; A3++) {
+    const B3 = s2[I2 * n2 + A3], t3 = s2[I2 * n2 + (A3 - 1)];
+    let i3 = null, o3 = false, h3 = -1;
+    if (1 === B3 && 0 === t3 ? (o3 = true, i3 = { x: A3, y: I2 }, h3 = 2) : 0 === B3 && t3 >= 1 && -1 !== t3 && 1 === t3 && (o3 = false, i3 = { x: A3 - 1, y: I2 }, h3 = 6), i3) {
+      if (0 === E2 && !o3) {
+        s2[i3.y * n2 + i3.x] = -1;
+        continue;
+      }
+      const A4 = r2++, I3 = C(s2, n2, a2, i3, h3, A4);
+      if (I3 && I3.length > 0) {
+        let B4 = I3;
+        2 === e2 && (B4 = Q(I3));
+        const C2 = B4.map((A5) => ({ x: A5.x - 1, y: A5.y - 1 }));
+        if (C2.length >= (2 === e2 ? 4 : g)) {
+          const I4 = { id: A4, points: C2, isOuter: o3 };
+          c2.push(I4);
+        }
+      } else 1 === s2[i3.y * n2 + i3.x] && (s2[i3.y * n2 + i3.x] = A4);
+    }
+  }
+  c2.forEach((A3) => {
+    A3.area = (function(A4) {
+      let I2 = 0;
+      const g2 = A4.length;
+      if (g2 < 3) return 0;
+      for (let B3 = 0; B3 < g2; B3++) {
+        const C2 = (B3 + 1) % g2;
+        I2 += A4[B3].x * A4[C2].y, I2 -= A4[C2].x * A4[B3].y;
+      }
+      return Math.abs(I2) / 2;
+    })(A3.points), A3.boundingBox = (function(A4) {
+      if (0 === A4.length) return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+      let I2 = A4[0].x, g2 = A4[0].y, B3 = A4[0].x, C2 = A4[0].y;
+      for (let Q2 = 1; Q2 < A4.length; Q2++) {
+        const t3 = A4[Q2];
+        I2 = Math.min(I2, t3.x), g2 = Math.min(g2, t3.y), B3 = Math.max(B3, t3.x), C2 = Math.max(C2, t3.y);
+      }
+      return { minX: I2, minY: g2, maxX: B3, maxY: C2 };
+    })(A3.points);
+  });
+  const h2 = c2.filter((A3) => A3.area >= o2);
+  return h2.sort((A3, I2) => I2.area - A3.area), B2.debug && (B2.debug.labels = s2, B2.debug.rawContours = c2, B2.debug.finalContours = h2), h2;
+}
+function C(A2, I2, g2, B2, C2, Q2) {
+  const t2 = [], i2 = /* @__PURE__ */ new Set();
+  let E2 = B2.x, e2 = B2.y;
+  const o2 = E2, n2 = e2;
+  let a2 = -1;
+  A2[n2 * I2 + o2] = Q2;
+  let s2 = 0;
+  const c2 = I2 * g2, r2 = [0, 1, 1, 1, 0, -1, -1, -1], h2 = [-1, -1, 0, 1, 1, 1, 0, -1];
+  for (; s2++ < c2; ) {
+    let B3;
+    if (-1 === a2) {
+      let Q3 = false;
+      for (let t3 = 0; t3 < 8; t3++) {
+        B3 = C2 + t3 & 7;
+        const i3 = E2 + r2[B3], o3 = e2 + h2[B3];
+        if (i3 >= 0 && i3 < I2 && o3 >= 0 && o3 < g2 && A2[o3 * I2 + i3] > 0) {
+          Q3 = true;
+          break;
+        }
+      }
+      if (!Q3) return null;
+    } else B3 = a2 + 2 & 7;
+    let s3 = -1, c3 = -1;
+    for (let C3 = 0; C3 < 8; C3++) {
+      const Q3 = B3 + C3 & 7, t3 = E2 + r2[Q3], i3 = e2 + h2[Q3];
+      if (t3 >= 0 && t3 < I2 && i3 >= 0 && i3 < g2 && A2[i3 * I2 + t3] > 0) {
+        s3 = t3, c3 = i3, a2 = Q3 + 4 & 7;
+        break;
+      }
+    }
+    if (-1 === s3) {
+      0 === t2.length && t2.push({ x: E2, y: e2 });
+      break;
+    }
+    const l2 = e2 * I2 + E2;
+    if (i2.has(l2)) return t2;
+    t2.push({ x: E2, y: e2 }), i2.add(l2);
+    const y2 = c3 * I2 + s3;
+    if (1 === A2[y2] && (A2[y2] = Q2), E2 = s3, e2 = c3, E2 === o2 && e2 === n2) break;
+  }
+  return s2 >= c2 ? null : t2;
+}
+function Q(A2) {
+  const I2 = A2.length;
+  if (I2 <= 2) return A2;
+  const g2 = [], B2 = A2[I2 - 1], C2 = A2[0];
+  let Q2 = B2, t2 = C2, i2 = A2[1], E2 = t2.x - Q2.x, e2 = t2.y - Q2.y, o2 = i2.x - t2.x, n2 = i2.y - t2.y;
+  E2 * n2 !== e2 * o2 && g2.push(t2);
+  for (let a2 = 1; a2 < I2 - 1; a2++) Q2 = A2[a2 - 1], t2 = A2[a2], i2 = A2[a2 + 1], E2 = t2.x - Q2.x, e2 = t2.y - Q2.y, o2 = i2.x - t2.x, n2 = i2.y - t2.y, E2 * n2 !== e2 * o2 && g2.push(t2);
+  if (Q2 = A2[I2 - 2], t2 = B2, i2 = C2, E2 = t2.x - Q2.x, e2 = t2.y - Q2.y, o2 = i2.x - t2.x, n2 = i2.y - t2.y, E2 * n2 !== e2 * o2 && g2.push(t2), 0 === g2.length) {
+    if (1 === I2) return [A2[0]];
+    if (2 === I2) return A2;
+    let g3 = 0, B3 = 1;
+    const Q3 = C2.x, t3 = C2.y;
+    for (let C3 = 1; C3 < I2; C3++) {
+      const I3 = A2[C3], i3 = I3.x - Q3, E3 = I3.y - t3, e3 = i3 * i3 + E3 * E3;
+      e3 > g3 && (g3 = e3, B3 = C3);
+    }
+    return [C2, A2[B3]];
+  }
+  return g2;
+}
+function t(A2, I2 = 1) {
+  if (A2.length <= 2) return A2;
+  let g2 = 0, B2 = 0;
+  const C2 = A2[0], Q2 = A2[A2.length - 1];
+  for (let t2 = 1; t2 < A2.length - 1; t2++) {
+    const I3 = i(A2[t2], C2, Q2);
+    I3 > g2 && (g2 = I3, B2 = t2);
+  }
+  if (g2 > I2) {
+    const g3 = t(A2.slice(0, B2 + 1), I2), C3 = t(A2.slice(B2), I2);
+    return g3.slice(0, -1).concat(C3);
+  }
+  return [C2, Q2];
+}
+function i(A2, I2, g2) {
+  const B2 = g2.x - I2.x, C2 = g2.y - I2.y, Q2 = B2 * B2 + C2 * C2;
+  if (0 === Q2) return Math.sqrt(Math.pow(A2.x - I2.x, 2) + Math.pow(A2.y - I2.y, 2));
+  const t2 = ((A2.x - I2.x) * B2 + (A2.y - I2.y) * C2) / Q2;
+  let i2, E2;
+  t2 < 0 ? (i2 = I2.x, E2 = I2.y) : t2 > 1 ? (i2 = g2.x, E2 = g2.y) : (i2 = I2.x + t2 * B2, E2 = I2.y + t2 * C2);
+  const e2 = A2.x - i2, o2 = A2.y - E2;
+  return Math.sqrt(e2 * e2 + o2 * o2);
+}
+function E(A2, I2 = 0.02) {
+  return t(A2, I2 * (function(A3) {
+    let I3 = 0;
+    const g2 = A3.length;
+    if (g2 < 2) return 0;
+    for (let B2 = 0; B2 < g2; B2++) {
+      const C2 = (B2 + 1) % g2, Q2 = A3[B2].x - A3[C2].x, t2 = A3[B2].y - A3[C2].y;
+      I3 += Math.sqrt(Q2 * Q2 + t2 * t2);
+    }
+    return I3;
+  })(A2));
+}
+function e(A2, I2) {
+  return Math.hypot(I2.x - A2.x, I2.y - A2.y);
+}
+function o(A2) {
+  let I2 = 0, g2 = 0;
+  for (const B2 of A2) I2 += B2.x, g2 += B2.y;
+  return { x: I2 / A2.length, y: g2 / A2.length };
+}
+function n(A2, I2 = {}) {
+  if (!A2 || !A2.points || A2.points.length < 4) return null;
+  const g2 = I2.epsilon || 0.02, B2 = (function(A3, I3) {
+    if (!A3 || A3.length < 4) return null;
+    const g3 = [I3, 1.3 * I3, 1.6 * I3, 2 * I3], B3 = /* @__PURE__ */ new Set();
+    for (const C3 of g3) {
+      const I4 = Math.min(0.12, C3), g4 = I4.toFixed(4);
+      if (B3.has(g4)) continue;
+      B3.add(g4);
+      const Q2 = a(E(A3, I4));
+      if (Q2 && 4 === Q2.length) return Q2;
+    }
+    return null;
+  })(A2.points, g2);
+  let C2;
+  return B2 && 4 === B2.length ? C2 = (function(A3) {
+    if (4 !== A3.length) return null;
+    const I3 = o(A3), g3 = [...A3].sort((A4, g4) => Math.atan2(A4.y - I3.y, A4.x - I3.x) - Math.atan2(g4.y - I3.y, g4.x - I3.x));
+    let B3 = 1 / 0, C3 = 0;
+    for (let t2 = 0; t2 < 4; t2++) {
+      const A4 = g3[t2].x + g3[t2].y;
+      A4 < B3 && (B3 = A4, C3 = t2);
+    }
+    const Q2 = [g3[C3], g3[(C3 + 1) % 4], g3[(C3 + 2) % 4], g3[(C3 + 3) % 4]];
+    return { topLeft: Q2[0], topRight: Q2[1], bottomRight: Q2[2], bottomLeft: Q2[3] };
+  })(B2) : (C2 = (function(A3) {
+    if (!A3 || A3.length < 4) return null;
+    const I3 = o(A3);
+    let g3 = null, B3 = null, C3 = null, Q2 = null, t2 = 0, i2 = 0, E2 = 0, n2 = 0;
+    for (const o2 of A3) {
+      const A4 = e(o2, I3);
+      o2.x < I3.x && o2.y < I3.y ? A4 > t2 && (g3 = o2, t2 = A4) : o2.x > I3.x && o2.y < I3.y ? A4 > i2 && (B3 = o2, i2 = A4) : o2.x > I3.x && o2.y > I3.y ? A4 > E2 && (C3 = o2, E2 = A4) : o2.x < I3.x && o2.y > I3.y && A4 > n2 && (Q2 = o2, n2 = A4);
+    }
+    return g3 && B3 && C3 && Q2 ? { topLeft: g3, topRight: B3, bottomRight: C3, bottomLeft: Q2 } : null;
+  })(A2.points), C2 && C2.topLeft && C2.topRight && C2.bottomRight && C2.bottomLeft || (C2 = (function(A3) {
+    if (!A3 || 0 === A3.length) return null;
+    let I3 = A3[0], g3 = A3[0], B3 = A3[0], C3 = A3[0], Q2 = I3.x + I3.y, t2 = g3.x - g3.y, i2 = B3.x + B3.y, E2 = C3.x - C3.y;
+    for (let e2 = 1; e2 < A3.length; e2++) {
+      const o2 = A3[e2], n2 = o2.x + o2.y, a2 = o2.x - o2.y;
+      n2 < Q2 && (Q2 = n2, I3 = o2), n2 > i2 && (i2 = n2, B3 = o2), a2 > t2 && (t2 = a2, g3 = o2), a2 < E2 && (E2 = a2, C3 = o2);
+    }
+    return { topLeft: I3, topRight: g3, bottomRight: B3, bottomLeft: C3 };
+  })(A2.points))), C2 && C2.topLeft && C2.topRight && C2.bottomRight && C2.bottomLeft ? C2 : null;
+}
+function a(A2) {
+  if (!A2 || A2.length < 4) return null;
+  if (4 === A2.length) return A2;
+  if (A2.length > 8) return null;
+  let I2 = (function(A3, I3) {
+    if (!A3 || 0 === A3.length) return [];
+    const g2 = [];
+    for (const B2 of A3) (0 === g2.length || e(B2, g2[g2.length - 1]) > I3) && g2.push(B2);
+    g2.length > 2 && e(g2[0], g2[g2.length - 1]) <= I3 && g2.pop();
+    return g2;
+  })(A2, 6);
+  return 4 === I2.length ? I2 : (I2.length, null);
+}
+function c() {
+  return null !== s && 0 !== s.byteLength || (s = new Uint8Array(A.memory.buffer)), s;
+}
+function h(A2, I2) {
+  const g2 = I2(1 * A2.length, 1) >>> 0;
+  return c().set(A2, g2 / 1), r = A2.length, g2;
+}
+function l(A2, I2) {
+  return A2 >>>= 0, c().subarray(A2 / 1, A2 / 1 + I2);
+}
+function D() {
+  return null !== y && 0 !== y.byteLength || (y = new Float32Array(A.memory.buffer)), y;
+}
+function w(I2, g2, B2, C2, Q2) {
+  const t2 = (function(A2, I3) {
+    const g3 = I3(4 * A2.length, 4) >>> 0;
+    return D().set(A2, g3 / 4), r = A2.length, g3;
+  })(I2, A.__wbindgen_malloc), i2 = r, E2 = A.hysteresis_thresholding(t2, i2, g2, B2, C2, Q2);
+  var e2 = l(E2[0], E2[1]).slice();
+  return A.__wbindgen_free(E2[0], 1 * E2[1], 1), e2;
+}
+function f(I2, g2) {
+  const B2 = g2(2 * I2.length, 2) >>> 0;
+  return (null !== d && 0 !== d.byteLength || (d = new Uint16Array(A.memory.buffer)), d).set(I2, B2 / 2), r = I2.length, B2;
+}
+function u(I2, g2, B2, C2, Q2) {
+  const t2 = f(I2, A.__wbindgen_malloc), i2 = r, E2 = f(g2, A.__wbindgen_malloc), e2 = r, o2 = A.non_maximum_suppression(t2, i2, E2, e2, B2, C2, Q2);
+  var n2, a2, s2 = (n2 = o2[0], a2 = o2[1], n2 >>>= 0, D().subarray(n2 / 4, n2 / 4 + a2)).slice();
+  return A.__wbindgen_free(o2[0], 4 * o2[1], 4), s2;
+}
+async function m(I2) {
+  if (void 0 !== A) return A;
+  if (void 0 !== I2 && Object.getPrototypeOf(I2) === Object.prototype && ({ module_or_path: I2 } = I2), void 0 === I2) throw new Error("scanic: WASM module bytes must be passed to init().");
+  const g2 = (function() {
+    const I3 = { wbg: {} };
+    return I3.wbg.__wbindgen_init_externref_table = function() {
+      const I4 = A.__wbindgen_export_0, g3 = I4.grow(4);
+      I4.set(0, void 0), I4.set(g3 + 0, void 0), I4.set(g3 + 1, null), I4.set(g3 + 2, true), I4.set(g3 + 3, false);
+    }, I3;
+  })();
+  ("string" == typeof I2 || "function" == typeof Request && I2 instanceof Request || "function" == typeof URL && I2 instanceof URL) && (I2 = fetch(I2));
+  const { instance: B2, module: C2 } = await (async function(A2, I3) {
+    if ("function" == typeof Response && A2 instanceof Response) {
+      if ("function" == typeof WebAssembly.instantiateStreaming) try {
+        return await WebAssembly.instantiateStreaming(A2, I3);
+      } catch (g3) {
+        if ("application/wasm" == A2.headers.get("Content-Type")) throw g3;
+      }
+      const B3 = await A2.arrayBuffer();
+      return await WebAssembly.instantiate(B3, I3);
+    }
+    {
+      const g3 = await WebAssembly.instantiate(A2, I3);
+      return g3 instanceof WebAssembly.Instance ? { instance: g3, module: A2 } : g3;
+    }
+  })(await I2, g2);
+  return (function(I3, g3) {
+    return A = I3.exports, m.__wbindgen_wasm_module = g3, y = null, d = null, s = null, A.__wbindgen_start(), A;
+  })(B2, C2);
+}
+function F(A2) {
+  if ("function" == typeof atob) {
+    const I2 = atob(A2), g2 = new Uint8Array(I2.length);
+    for (let A3 = 0; A3 < I2.length; A3++) g2[A3] = I2.charCodeAt(A3);
+    return g2;
+  }
+  return Uint8Array.from(Buffer.from(A2, "base64"));
+}
+async function J() {
+  if (!(function() {
+    if (null !== p) return p;
+    let A2 = false;
+    if ("object" == typeof WebAssembly && "function" == typeof WebAssembly.validate) {
+      const I2 = 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]), g2 = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 111, 3, 2, 1, 0, 10, 6, 1, 4, 0, 208, 111, 11]);
+      try {
+        A2 = WebAssembly.validate(I2) && WebAssembly.validate(g2);
+      } catch {
+        A2 = false;
+      }
+    }
+    return p = A2, A2;
+  })()) throw new Error("scanic: WebAssembly features required by the WASM module (reference-types, SIMD) are unavailable in this engine; using the JavaScript fallback.");
+  return await m({ module_or_path: F("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") });
+}
+function G() {
+  return N || (N = J().catch((A2) => {
+    throw N = null, A2;
+  })), N;
+}
+function k(A2, I2, g2, B2 = 5, C2 = 0) {
+  0 === C2 && (C2 = 0.3 * (0.5 * (B2 - 1) - 1) + 0.8);
+  const Q2 = Math.floor(B2 / 2), t2 = (function(A3, I3) {
+    const g3 = new Float32Array(A3), B3 = Math.floor(A3 / 2);
+    let C3 = 0;
+    for (let Q3 = 0; Q3 < A3; Q3++) {
+      const A4 = Q3 - B3;
+      g3[Q3] = Math.exp(-A4 * A4 / (2 * I3 * I3)), C3 += g3[Q3];
+    }
+    for (let Q3 = 0; Q3 < A3; Q3++) g3[Q3] /= C3;
+    return g3;
+  })(B2, C2), i2 = new Uint8ClampedArray(I2 * g2), E2 = new Uint8ClampedArray(I2 * g2);
+  for (let e2 = 0; e2 < g2; e2++) {
+    const g3 = e2 * I2;
+    for (let B3 = 0; B3 < I2; B3++) {
+      let C3 = 0;
+      for (let i3 = -Q2; i3 <= Q2; i3++) {
+        C3 += A2[g3 + Math.min(I2 - 1, Math.max(0, B3 + i3))] * t2[Q2 + i3];
+      }
+      i2[g3 + B3] = C3;
+    }
+  }
+  for (let e2 = 0; e2 < I2; e2++) for (let A3 = 0; A3 < g2; A3++) {
+    let B3 = 0;
+    for (let C3 = -Q2; C3 <= Q2; C3++) {
+      B3 += i2[Math.min(g2 - 1, Math.max(0, A3 + C3)) * I2 + e2] * t2[Q2 + C3];
+    }
+    E2[A3 * I2 + e2] = Math.round(B3);
+  }
+  return E2;
+}
+function S(A2, I2, g2, B2, C2) {
+  const Q2 = new Uint8Array(I2 * g2), t2 = [];
+  for (let e2 = 1; e2 < g2 - 1; e2++) for (let g3 = 1; g3 < I2 - 1; g3++) {
+    const i3 = e2 * I2 + g3, E3 = A2[i3];
+    E3 >= C2 ? (Q2[i3] = 2, t2.push({ x: g3, y: e2 })) : Q2[i3] = E3 >= B2 ? 0 : 1;
+  }
+  for (let e2 = 0; e2 < I2; e2++) Q2[e2] = 1, Q2[(g2 - 1) * I2 + e2] = 1;
+  for (let e2 = 1; e2 < g2 - 1; e2++) Q2[e2 * I2] = 1, Q2[e2 * I2 + I2 - 1] = 1;
+  const i2 = [-1, 0, 1, -1, 1, -1, 0, 1], E2 = [-1, -1, -1, 0, 0, 1, 1, 1];
+  for (; t2.length > 0; ) {
+    const { x: A3, y: g3 } = t2.pop();
+    for (let B3 = 0; B3 < 8; B3++) {
+      const C3 = A3 + i2[B3], e2 = g3 + E2[B3], o2 = e2 * I2 + C3;
+      0 === Q2[o2] && (Q2[o2] = 2, t2.push({ x: C3, y: e2 }));
+    }
+  }
+  return Q2;
+}
+async function M(I2, g2 = {}) {
+  const B2 = !(!g2.debug || g2.debug._timingsOnly), C2 = [], Q2 = performance.now();
+  let t2, i2, E2;
+  if (g2.skipGrayscale || false) t2 = g2.width, i2 = g2.height, E2 = I2, B2 && (g2.debug.grayscale = E2);
+  else {
+    t2 = I2.width, i2 = I2.height;
+    let A2 = performance.now();
+    E2 = (function(A3) {
+      const { width: I3, height: g3, data: B3 } = A3, C3 = new Uint8ClampedArray(I3 * g3);
+      for (let Q4 = 0, t3 = 0; Q4 < B3.length; Q4 += 4, t3++) C3[t3] = 54 * B3[Q4] + 183 * B3[Q4 + 1] + 19 * B3[Q4 + 2] >> 8;
+      return C3;
+    })(I2);
+    let Q3 = performance.now();
+    C2.push({ step: "Grayscale", ms: (Q3 - A2).toFixed(2) }), B2 && (g2.debug.grayscale = E2);
+  }
+  let e2 = void 0 !== g2.lowThreshold ? g2.lowThreshold : null, o2 = void 0 !== g2.highThreshold ? g2.highThreshold : null;
+  if (null === e2 || null === o2) {
+    const A2 = 1024, I3 = new Uint32Array(A2);
+    let g3 = 0;
+    for (let e3 = 1; e3 < i2 - 1; e3++) for (let B4 = 1; B4 < t2 - 1; B4++) {
+      const C4 = e3 * t2 + B4, Q4 = -E2[C4 - t2 - 1] + E2[C4 - t2 + 1] - 2 * E2[C4 - 1] + 2 * E2[C4 + 1] - E2[C4 + t2 - 1] + E2[C4 + t2 + 1], i3 = -E2[C4 - t2 - 1] - 2 * E2[C4 - t2] - E2[C4 - t2 + 1] + E2[C4 + t2 - 1] + 2 * E2[C4 + t2] + E2[C4 + t2 + 1];
+      let o3 = Math.abs(Q4) + Math.abs(i3);
+      o3 >= A2 && (o3 = A2 - 1), o3 > 0 && (I3[o3]++, g3++);
+    }
+    const B3 = Math.round(0.7 * g3);
+    let C3 = 0, Q3 = 75;
+    for (let t3 = 1; t3 < A2; t3++) if (C3 += I3[t3], C3 >= B3) {
+      Q3 = t3;
+      break;
+    }
+    null === e2 && (e2 = Math.max(5, Math.round(0.5 * Q3))), null === o2 && (o2 = Math.min(500, Math.round(1.5 * Q3)));
+  }
+  const n2 = g2.kernelSize || 5, a2 = g2.sigma || 0, s2 = void 0 !== g2.L2gradient && g2.L2gradient, c2 = void 0 === g2.applyDilation || g2.applyDilation, y2 = g2.dilationKernelSize || 5, D2 = void 0 !== g2.useWasmHysteresis && g2.useWasmHysteresis, d2 = void 0 !== g2.useWasmFullCanny && g2.useWasmFullCanny;
+  if (e2 >= o2 && ([e2, o2] = [o2, e2]), d2) try {
+    await G();
+    const I3 = performance.now(), D3 = new Uint8ClampedArray((function(I4, g3, B3, C3, Q3, t3, i3, E3, e3, o3) {
+      const n3 = h(I4, A.__wbindgen_malloc), a3 = r, s3 = A.canny_edge_detector_full(n3, a3, g3, B3, C3, Q3, t3, i3, E3, e3, o3);
+      var c3 = l(s3[0], s3[1]).slice();
+      return A.__wbindgen_free(s3[0], 1 * s3[1], 1), c3;
+    })(E2, t2, i2, e2, o2, n2, a2, s2, c2, y2)), w2 = (performance.now() - I3).toFixed(2);
+    C2.push({ step: "Edge Processing (WASM)", ms: w2 }), B2 && (g2.debug.finalEdges = D3), g2.debug ? g2.debug.timings = C2 : g2.debug = { timings: C2 };
+    const d3 = performance.now();
+    return C2.unshift({ step: "Edge Detection Total", ms: (d3 - Q2).toFixed(2) }), D3;
+  } catch (Y) {
+    if (!R) {
+      R = true;
+      Y instanceof Error ? Y.message : String(Y);
+    }
+  }
+  let f2, m2, N2, p2, F2, J2;
+  f2 = performance.now();
+  try {
+    await G(), N2 = (function(I3, g3, B3, C3, Q3) {
+      const t3 = h(I3, A.__wbindgen_malloc), i3 = r, E3 = A.blur(t3, i3, g3, B3, C3, Q3);
+      var e3 = l(E3[0], E3[1]).slice();
+      return A.__wbindgen_free(E3[0], 1 * E3[1], 1), e3;
+    })(E2, t2, i2, n2, a2);
+  } catch {
+    N2 = k(E2, t2, i2, n2, a2);
+  }
+  m2 = performance.now(), C2.push({ step: "Gaussian Blur", ms: (m2 - f2).toFixed(2) }), B2 && (g2.debug.blurred = N2), f2 = performance.now();
+  {
+    const A2 = (function(A3, I3, g3) {
+      const B3 = new Int16Array(I3 * g3), C3 = new Int16Array(I3 * g3);
+      for (let Q3 = 1; Q3 < g3 - 1; Q3++) {
+        const g4 = Q3 * I3, t3 = (Q3 - 1) * I3, i3 = (Q3 + 1) * I3;
+        for (let Q4 = 1; Q4 < I3 - 1; Q4++) {
+          const I4 = g4 + Q4, E3 = A3[t3 + Q4 - 1], e3 = A3[t3 + Q4], o3 = A3[t3 + Q4 + 1], n3 = A3[g4 + Q4 - 1], a3 = A3[g4 + Q4 + 1], s3 = A3[i3 + Q4 - 1], c3 = A3[i3 + Q4], r2 = A3[i3 + Q4 + 1], h2 = o3 - E3 + 2 * (a3 - n3) + (r2 - s3), l2 = s3 + 2 * c3 + r2 - (E3 + 2 * e3 + o3);
+          B3[I4] = h2, C3[I4] = l2;
+        }
+      }
+      return { dx: B3, dy: C3 };
+    })(N2, t2, i2);
+    p2 = A2.dx, F2 = A2.dy;
+  }
+  m2 = performance.now(), C2.push({ step: "Gradients", ms: (m2 - f2).toFixed(2) }), f2 = performance.now();
+  try {
+    await G(), J2 = await u(p2, F2, t2, i2, s2);
+  } catch {
+    J2 = (function(A2, I3, g3, B3, C3) {
+      const Q3 = new Float32Array(g3 * B3), t3 = new Float32Array(g3 * B3);
+      for (let i3 = 0; i3 < A2.length; i3++) {
+        const g4 = A2[i3], B4 = I3[i3];
+        Q3[i3] = C3 ? Math.sqrt(g4 * g4 + B4 * B4) : Math.abs(g4) + Math.abs(B4);
+      }
+      for (let i3 = 1; i3 < B3 - 1; i3++) for (let B4 = 1; B4 < g3 - 1; B4++) {
+        const C4 = i3 * g3 + B4, E3 = Q3[C4];
+        if (0 === E3) {
+          t3[C4] = 0;
+          continue;
+        }
+        const e3 = A2[C4], o3 = I3[C4];
+        let n3 = 0, a3 = 0;
+        const s3 = Math.abs(e3), c3 = Math.abs(o3);
+        if (c3 > 2.4142 * s3) n3 = Q3[C4 - g3], a3 = Q3[C4 + g3];
+        else if (s3 > 2.4142 * c3) n3 = Q3[C4 - 1], a3 = Q3[C4 + 1];
+        else {
+          const A3 = (e3 ^ o3) < 0 ? -1 : 1;
+          o3 > 0 ? (n3 = Q3[(i3 - 1) * g3 + (B4 - A3)], a3 = Q3[(i3 + 1) * g3 + (B4 + A3)]) : (n3 = Q3[(i3 + 1) * g3 + (B4 - A3)], a3 = Q3[(i3 - 1) * g3 + (B4 + A3)]), e3 > 0 && o3 > 0 || e3 < 0 && o3 < 0 ? (n3 = Q3[(i3 - 1) * g3 + (B4 + 1)], a3 = Q3[(i3 + 1) * g3 + (B4 - 1)]) : (n3 = Q3[(i3 - 1) * g3 + (B4 - 1)], a3 = Q3[(i3 + 1) * g3 + (B4 + 1)]);
+        }
+        t3[C4] = E3 >= n3 && E3 >= a3 ? E3 : 0;
+      }
+      return t3;
+    })(p2, F2, t2, i2, s2);
+  }
+  m2 = performance.now(), C2.push({ step: "Non-Max Suppression", ms: (m2 - f2).toFixed(2) }), f2 = performance.now();
+  const M2 = s2 ? e2 * e2 : e2, b = s2 ? o2 * o2 : o2;
+  let L;
+  if (D2) try {
+    await G(), L = w(J2, t2, i2, M2, b);
+  } catch (q) {
+    L = S(J2, t2, i2, M2, b);
+  }
+  else L = S(J2, t2, i2, M2, b);
+  m2 = performance.now(), C2.push({ step: "Hysteresis", ms: (m2 - f2).toFixed(2) }), f2 = performance.now();
+  const x = new Uint8ClampedArray(t2 * i2);
+  for (let A2 = 0; A2 < L.length; A2++) x[A2] = 2 === L[A2] ? 255 : 0;
+  m2 = performance.now(), C2.push({ step: "Binary Image", ms: (m2 - f2).toFixed(2) }), f2 = performance.now();
+  let U = x;
+  if (c2) try {
+    await G(), U = (function(I3, g3, B3, C3) {
+      const Q3 = h(I3, A.__wbindgen_malloc), t3 = r, i3 = A.dilate(Q3, t3, g3, B3, C3);
+      var E3 = l(i3[0], i3[1]).slice();
+      return A.__wbindgen_free(i3[0], 1 * i3[1], 1), E3;
+    })(x, t2, i2, y2);
+  } catch {
+    U = (function(A2, I3, g3, B3 = 5) {
+      const C3 = Math.floor(B3 / 2), Q3 = new Uint8ClampedArray(I3 * g3), t3 = new Uint8ClampedArray(I3 * g3);
+      for (let i3 = 0; i3 < g3; i3++) {
+        const g4 = i3 * I3;
+        for (let B4 = 0; B4 < I3; B4++) {
+          let t4 = 0;
+          for (let Q4 = -C3; Q4 <= C3; Q4++) {
+            const C4 = B4 + Q4;
+            if (C4 >= 0 && C4 < I3) {
+              const I4 = A2[g4 + C4];
+              I4 > t4 && (t4 = I4);
+            }
+          }
+          Q3[g4 + B4] = t4;
+        }
+      }
+      for (let i3 = 0; i3 < I3; i3++) for (let A3 = 0; A3 < g3; A3++) {
+        let B4 = 0;
+        for (let t4 = -C3; t4 <= C3; t4++) {
+          const C4 = A3 + t4;
+          if (C4 >= 0 && C4 < g3) {
+            const A4 = Q3[C4 * I3 + i3];
+            A4 > B4 && (B4 = A4);
+          }
+        }
+        t3[A3 * I3 + i3] = B4;
+      }
+      return t3;
+    })(x, t2, i2, y2);
+  }
+  if (m2 = performance.now(), C2.push({ step: "Dilation", ms: (m2 - f2).toFixed(2) }), B2) {
+    g2.debug.dx = p2, g2.debug.dy = F2;
+    const A2 = new Float32Array(t2 * i2);
+    for (let I3 = 0; I3 < p2.length; I3++) {
+      const g3 = p2[I3], B3 = F2[I3];
+      A2[I3] = s2 ? Math.sqrt(g3 * g3 + B3 * B3) : Math.abs(g3) + Math.abs(B3);
+    }
+    g2.debug.magnitude = A2, g2.debug.suppressed = J2, g2.debug.edgeMap = L, g2.debug.cannyEdges = x, g2.debug.finalEdges = U;
+  }
+  g2.debug ? g2.debug.timings = C2 : g2.debug || (g2.debug = { timings: C2 });
+  const H = performance.now();
+  return C2.unshift({ step: "Edge Detection Total", ms: (H - Q2).toFixed(2) }), U;
+}
+function Z(A2) {
+  return A2 <= 0 ? 0 : A2 >= 1 ? 1 : A2;
+}
+function X(A2, I2) {
+  return Math.hypot(A2.x - I2.x, A2.y - I2.y);
+}
+function V(A2) {
+  return [X(A2.topLeft, A2.topRight), X(A2.topRight, A2.bottomRight), X(A2.bottomRight, A2.bottomLeft), X(A2.bottomLeft, A2.topLeft)];
+}
+function j(A2) {
+  const I2 = (function(A3) {
+    const I3 = [A3.topLeft, A3.topRight, A3.bottomRight, A3.bottomLeft], g3 = [];
+    for (let B2 = 0; B2 < I3.length; B2++) {
+      const A4 = I3[(B2 + I3.length - 1) % I3.length], C2 = I3[B2], Q2 = I3[(B2 + 1) % I3.length], t2 = A4.x - C2.x, i2 = A4.y - C2.y, E2 = Q2.x - C2.x, e2 = Q2.y - C2.y, o2 = t2 * E2 + i2 * e2, n2 = Math.max(1e-6, Math.hypot(t2, i2) * Math.hypot(E2, e2)), a2 = Math.max(-1, Math.min(1, o2 / n2));
+      g3.push(180 * Math.acos(a2) / Math.PI);
+    }
+    return g3;
+  })(A2);
+  let g2 = 0;
+  for (const B2 of I2) {
+    g2 += Z(1 - Math.abs(B2 - 90) / 55);
+  }
+  return g2 / Math.max(1, I2.length);
+}
+function O(A2, I2) {
+  const g2 = Number(I2.isValid) - Number(A2.isValid);
+  if (0 !== g2) return g2;
+  const B2 = I2.confidence - A2.confidence;
+  if (!(Math.abs(B2) < 0.015) && 0 !== B2) return B2;
+  const C2 = Math.abs((A2.approxCount ?? 99) - 4) - Math.abs((I2.approxCount ?? 99) - 4);
+  if (0 !== C2) return C2;
+  const Q2 = (I2.rightAngleScore ?? 0) - (A2.rightAngleScore ?? 0);
+  if (Math.abs(Q2) > 1e-6) return Q2;
+  const t2 = Math.abs(1 - (A2.contourFitRatio ?? 1)) - Math.abs(1 - (I2.contourFitRatio ?? 1));
+  return Math.abs(t2) > 1e-6 ? t2 : B2 || I2.score - A2.score || I2.coverageRatio - A2.coverageRatio || I2.area - A2.area;
+}
+function z(A2, I2, g2, B2, C2 = {}) {
+  const Q2 = C2.epsilon || 0.02, t2 = E(A2.points, Q2).length, i2 = n(A2, { epsilon: Q2 });
+  if (!i2) return { contour: A2, corners: null, score: 0, confidence: 0, isValid: false, area: A2.area || 0, fillRatio: 0, coverageRatio: 0, cornersArea: 0, approxCount: t2, convex: false, edgeSupport: 0, aspectRatio: 1 / 0, minSide: 0, rightAngleScore: 0, oppositeSideConsistency: 0, contourFitRatio: 0, contourFitScore: 0 };
+  const e2 = g2 * B2, o2 = A2.area || 0, a2 = A2.boundingBox || { minX: 0, minY: 0, maxX: 0, maxY: 0 }, s2 = o2 / Math.max(1, (a2.maxX - a2.minX + 1) * (a2.maxY - a2.minY + 1)), c2 = (function(A3) {
+    if (!A3) return 0;
+    const I3 = [A3.topLeft, A3.topRight, A3.bottomRight, A3.bottomLeft];
+    let g3 = 0;
+    for (let B3 = 0; B3 < I3.length; B3++) {
+      const A4 = (B3 + 1) % I3.length;
+      g3 += I3[B3].x * I3[A4].y - I3[A4].x * I3[B3].y;
+    }
+    return Math.abs(g3) / 2;
+  })(i2), r2 = c2 / Math.max(1, e2), h2 = V(i2), l2 = Math.min(...h2), y2 = (h2[0] + h2[2]) / 2, D2 = (h2[1] + h2[3]) / 2, w2 = y2 > D2 ? y2 / Math.max(1e-6, D2) : D2 / Math.max(1e-6, y2), d2 = (function(A3) {
+    const I3 = [A3.topLeft, A3.topRight, A3.bottomRight, A3.bottomLeft], g3 = [];
+    for (let C3 = 0; C3 < I3.length; C3++) {
+      const A4 = I3[C3], B4 = I3[(C3 + 1) % I3.length], Q3 = I3[(C3 + 2) % I3.length], t3 = (B4.x - A4.x) * (Q3.y - B4.y) - (B4.y - A4.y) * (Q3.x - B4.x);
+      Math.abs(t3) < 1e-6 || g3.push(Math.sign(t3));
+    }
+    if (g3.length < 3) return false;
+    const B3 = g3[0];
+    return g3.every((A4) => A4 === B3);
+  })(i2), f2 = (function(A3, I3, g3, B3) {
+    if (!A3?.points || 0 === A3.points.length) return 0;
+    const C3 = Math.max(1, Math.floor(A3.points.length / 240));
+    let Q3 = 0, t3 = 0;
+    for (let i3 = 0; i3 < A3.points.length; i3 += C3) {
+      const C4 = A3.points[i3], E2 = Math.max(0, Math.min(g3 - 1, 0 | C4.x)), e3 = Math.max(0, Math.min(B3 - 1, 0 | C4.y));
+      Q3++;
+      let o3 = false;
+      for (let A4 = -1; A4 <= 1 && !o3; A4++) {
+        const C5 = e3 + A4;
+        if (!(C5 < 0 || C5 >= B3)) for (let A5 = -1; A5 <= 1; A5++) {
+          const B4 = E2 + A5;
+          if (!(B4 < 0 || B4 >= g3) && I3[C5 * g3 + B4] > 0) {
+            o3 = true;
+            break;
+          }
+        }
+      }
+      o3 && t3++;
+    }
+    return 0 === Q3 ? 0 : t3 / Q3;
+  })(A2, I2, g2, B2), u2 = j(i2), m2 = (function(A3) {
+    const I3 = V(A3);
+    return (Math.min(I3[0], I3[2]) / Math.max(1e-6, Math.max(I3[0], I3[2])) + Math.min(I3[1], I3[3]) / Math.max(1e-6, Math.max(I3[1], I3[3]))) / 2;
+  })(i2), N2 = o2 / Math.max(1, c2), R2 = Z(1 - Math.abs(N2 - 1) / 0.55), p2 = 4 === t2 ? 1 : 5 === t2 ? 0.9 : 6 === t2 ? 0.7 : t2 <= 8 ? 0.5 : 0.28, F2 = Z(o2 / Math.max(1, 0.4 * e2)), J2 = Z((s2 - 0.08) / 0.72), G2 = Z((r2 - 0.03) / 0.82), k2 = void 0 !== C2.minDocumentSideRatio ? C2.minDocumentSideRatio : 0.06, S2 = void 0 !== C2.minDocumentCoverageRatio ? C2.minDocumentCoverageRatio : 0.04, M2 = void 0 !== C2.maxDocumentAspectRatio ? C2.maxDocumentAspectRatio : 8, b = void 0 !== C2.minDocumentFillRatio ? C2.minDocumentFillRatio : 0.07, L = void 0 !== C2.minContourFitRatio ? C2.minContourFitRatio : 0.11, x = void 0 !== C2.maxContourFitRatio ? C2.maxContourFitRatio : 1.2, U = void 0 !== C2.minRightAngleScore ? C2.minRightAngleScore : 0.42, H = void 0 !== C2.minOppositeSideConsistency ? C2.minOppositeSideConsistency : 0.3, Y = Math.min(g2, B2) * k2, q = (function(A3, I3 = 6) {
+    const g3 = [A3?.topLeft, A3?.topRight, A3?.bottomRight, A3?.bottomLeft];
+    if (g3.some((A4) => !A4 || !Number.isFinite(A4.x) || !Number.isFinite(A4.y))) return false;
+    for (let B3 = 0; B3 < g3.length; B3++) for (let A4 = B3 + 1; A4 < g3.length; A4++) if (X(g3[B3], g3[A4]) < I3) return false;
+    return true;
+  })(i2) && d2 && l2 >= Y && r2 >= S2 && w2 <= M2 && s2 >= b && N2 >= L && N2 <= x && u2 >= U && m2 >= H, v = 0.22 * F2 + 0.14 * J2 + 0.15 * p2 + 0.08 * (d2 ? 1 : 0) + 0.08 * f2 + 0.13 * G2 + 0.1 * u2 + 0.05 * m2 + 0.05 * R2;
+  return { contour: A2, corners: i2, score: v, confidence: q ? v : 0.33 * v, isValid: q, area: o2, fillRatio: s2, coverageRatio: r2, cornersArea: c2, approxCount: t2, convex: d2, edgeSupport: f2, aspectRatio: w2, minSide: l2, rightAngleScore: u2, oppositeSideConsistency: m2, contourFitRatio: N2, contourFitScore: R2 };
+}
+async function _(A2, I2, g2, C2, Q2 = {}) {
+  const t2 = Q2.debug ? {} : { _timingsOnly: true }, i2 = [];
+  t2 && !t2._timingsOnly && (t2.preprocessing = { scaledDimensions: { width: I2, height: g2 }, scaleFactor: C2, maxProcessingDimension: Q2.maxProcessingDimension || 800 });
+  const E2 = (function(A3 = {}) {
+    const I3 = A3.dilationKernelSize || 3, g3 = A3.dilationIterations || 1, B2 = void 0 === A3.applyDilation || A3.applyDilation, C3 = [{ name: "default", lowThreshold: A3.lowThreshold, highThreshold: A3.highThreshold, dilationKernelSize: I3, dilationIterations: g3, applyDilation: B2 }];
+    if (false === A3.enableDetectionCascade) return C3;
+    C3.push({ name: "connect-edges", lowThreshold: A3.lowThreshold, highThreshold: A3.highThreshold, dilationKernelSize: Math.max(I3, 5), dilationIterations: Math.max(g3, 2), applyDilation: true }), C3.push({ name: "no-dilation", lowThreshold: A3.lowThreshold, highThreshold: A3.highThreshold, dilationKernelSize: I3, dilationIterations: g3, applyDilation: false }), void 0 === A3.lowThreshold && void 0 === A3.highThreshold && C3.push({ name: "fixed-mid-thresholds", lowThreshold: 60, highThreshold: 180, dilationKernelSize: I3, dilationIterations: g3, applyDilation: B2 });
+    const Q3 = [], t3 = /* @__PURE__ */ new Set();
+    for (const i3 of C3) {
+      const A4 = [i3.lowThreshold, i3.highThreshold, i3.dilationKernelSize, i3.dilationIterations, i3.applyDilation].join(":");
+      t3.has(A4) || (t3.add(A4), Q3.push(i3));
+    }
+    return Q3;
+  })(Q2), e2 = [], o2 = async (t3, E3) => {
+    const e3 = t3.name || `pass-${E3 + 1}`, o3 = 0 === E3 ? "" : ` (${e3})`, n3 = Q2.debug ? {} : { _timingsOnly: true }, a3 = await M(A2, { width: I2, height: g2, lowThreshold: t3.lowThreshold, highThreshold: t3.highThreshold, dilationKernelSize: t3.dilationKernelSize, dilationIterations: t3.dilationIterations, applyDilation: t3.applyDilation, debug: n3, skipGrayscale: true, useWasmBlur: true, useWasmHysteresis: Q2.useWasmHysteresis, useWasmFullCanny: Q2.useWasmFullCanny });
+    n3.timings && n3.timings.forEach((A3) => {
+      "Edge Detection Total" !== A3.step && i2.push({ step: `${A3.step}${o3}`, ms: A3.ms });
+    });
+    let s3 = performance.now();
+    const c3 = B(a3, { minArea: (Q2.minArea || 1e3) / (C2 * C2), width: I2, height: g2 });
+    i2.push({ step: `Find Contours${o3}`, ms: (performance.now() - s3).toFixed(2) }), s3 = performance.now();
+    const { best: r3, candidates: h3 } = (function(A3, I3, g3, B2, C3 = {}) {
+      const Q3 = C3.maxCandidateContours || 12, t4 = A3.slice(0, Q3).map((A4, Q4) => ({ rankByArea: Q4, ...z(A4, I3, g3, B2, C3) })).sort(O);
+      return { best: t4[0] || null, candidates: t4 };
+    })(c3, a3, I2, g2, Q2);
+    return i2.push({ step: `Corner Detection${o3}`, ms: (performance.now() - s3).toFixed(2) }), { name: e3, params: { lowThreshold: t3.lowThreshold, highThreshold: t3.highThreshold, dilationKernelSize: t3.dilationKernelSize, dilationIterations: t3.dilationIterations, applyDilation: t3.applyDilation }, contours: c3, best: r3, candidates: h3 };
+  }, n2 = await o2(E2[0], 0);
+  if (e2.push(n2), (function(A3, I3 = {}) {
+    if (false === I3.enableDetectionCascade) return false;
+    if (!A3 || !A3.corners) return true;
+    const g3 = void 0 !== I3.minCascadeTriggerConfidence ? I3.minCascadeTriggerConfidence : 0.68;
+    return !A3.isValid || A3.confidence < g3 || A3.approxCount > 5 || A3.rightAngleScore < 0.55 || A3.contourFitRatio < 0.14;
+  })(n2.best, Q2)) for (let B2 = 1; B2 < E2.length; B2++) e2.push(await o2(E2[B2], B2));
+  const a2 = [];
+  for (const B2 of e2) for (const A3 of B2.candidates) a2.push({ ...A3, passName: B2.name, passParams: B2.params });
+  a2.sort(O);
+  const s2 = a2[0] || null, c2 = a2;
+  if (!s2 || !s2.corners) return { success: false, message: "No document detected", debug: t2._timingsOnly ? null : t2, timings: i2 };
+  t2 && !t2._timingsOnly && (t2.passes = e2.map((A3) => ({ name: A3.name, params: A3.params, contourCount: A3.contours.length, bestCandidate: A3.best ? { score: A3.best.score, confidence: A3.best.confidence, isValid: A3.best.isValid, approxCount: A3.best.approxCount, coverageRatio: A3.best.coverageRatio, fillRatio: A3.best.fillRatio, rightAngleScore: A3.best.rightAngleScore, contourFitRatio: A3.best.contourFitRatio } : null })), t2.candidates = c2.map((A3) => ({ passName: A3.passName, rankByArea: A3.rankByArea, area: A3.area, fillRatio: A3.fillRatio, coverageRatio: A3.coverageRatio, cornersArea: A3.cornersArea, approxCount: A3.approxCount, convex: A3.convex, edgeSupport: A3.edgeSupport, aspectRatio: A3.aspectRatio, minSide: A3.minSide, rightAngleScore: A3.rightAngleScore, oppositeSideConsistency: A3.oppositeSideConsistency, contourFitRatio: A3.contourFitRatio, contourFitScore: A3.contourFitScore, score: A3.score, confidence: A3.confidence, isValid: A3.isValid })), t2.selectedCandidate = c2[0] ? { passName: c2[0].passName, rankByArea: c2[0].rankByArea, area: c2[0].area, fillRatio: c2[0].fillRatio, coverageRatio: c2[0].coverageRatio, approxCount: c2[0].approxCount, edgeSupport: c2[0].edgeSupport, aspectRatio: c2[0].aspectRatio, minSide: c2[0].minSide, rightAngleScore: c2[0].rightAngleScore, oppositeSideConsistency: c2[0].oppositeSideConsistency, contourFitRatio: c2[0].contourFitRatio, score: c2[0].score, confidence: c2[0].confidence, isValid: c2[0].isValid } : null);
+  const r2 = s2.corners, h2 = s2.contour;
+  let l2 = r2;
+  return 1 !== C2 && (l2 = { topLeft: { x: r2.topLeft.x * C2, y: r2.topLeft.y * C2 }, topRight: { x: r2.topRight.x * C2, y: r2.topRight.y * C2 }, bottomRight: { x: r2.bottomRight.x * C2, y: r2.bottomRight.y * C2 }, bottomLeft: { x: r2.bottomLeft.x * C2, y: r2.bottomLeft.y * C2 } }), { success: true, contour: h2, corners: l2, confidence: s2.confidence, debug: t2._timingsOnly ? null : t2, timings: i2 };
+}
+function $(A2, I2, g2) {
+  const { topLeft: B2, topRight: C2, bottomRight: Q2, bottomLeft: t2 } = g2, i2 = Math.hypot(Q2.x - t2.x, Q2.y - t2.y), E2 = Math.hypot(C2.x - B2.x, C2.y - B2.y), e2 = Math.round(Math.max(i2, E2)), o2 = Math.hypot(C2.x - Q2.x, C2.y - Q2.y), n2 = Math.hypot(B2.x - t2.x, B2.y - t2.y), a2 = Math.round(Math.max(o2, n2));
+  A2.canvas.width = e2, A2.canvas.height = a2, (function(A3, I3, g3, B3, C3) {
+    const Q3 = I3 && "number" == typeof I3.width && "number" == typeof I3.height && I3.data, t3 = I3.width || I3.naturalWidth, i3 = I3.height || I3.naturalHeight, E3 = document.createElement("canvas");
+    E3.width = t3, E3.height = i3;
+    const e3 = E3.getContext("2d", { willReadFrequently: true });
+    Q3 ? e3.putImageData(I3, 0, 0) : e3.drawImage(I3, 0, 0, t3, i3);
+    const o3 = e3.getImageData(0, 0, t3, i3).data, n3 = (function(A4) {
+      const I4 = A4[0][0], g4 = A4[0][1], B4 = A4[0][2], C4 = A4[1][0], Q4 = A4[1][1], t4 = A4[1][2], i4 = A4[2][0], E4 = A4[2][1], e4 = A4[2][2], o4 = Q4 * e4 - t4 * E4, n4 = -(C4 * e4 - t4 * i4), a4 = C4 * E4 - Q4 * i4, s3 = -(g4 * e4 - B4 * E4), c3 = I4 * e4 - B4 * i4, r3 = -(I4 * E4 - g4 * i4), h3 = g4 * t4 - B4 * Q4, l3 = -(I4 * t4 - B4 * C4), y3 = I4 * Q4 - g4 * C4, D3 = I4 * o4 + g4 * n4 + B4 * a4;
+      if (0 === D3) throw new Error("Singular matrix");
+      return [[o4 / D3, s3 / D3, h3 / D3], [n4 / D3, c3 / D3, l3 / D3], [a4 / D3, r3 / D3, y3 / D3]];
+    })(g3), a3 = n3[0][0], s2 = n3[0][1], c2 = n3[0][2], r2 = n3[1][0], h2 = n3[1][1], l2 = n3[1][2], y2 = n3[2][0], D2 = n3[2][1], w2 = n3[2][2], d2 = A3.createImageData(B3, C3), f2 = d2.data, u2 = t3 - 1, m2 = i3 - 1;
+    for (let N2 = 0; N2 < C3; N2++) {
+      const A4 = s2 * N2 + c2, I4 = h2 * N2 + l2, g4 = D2 * N2 + w2;
+      for (let C4 = 0; C4 < B3; C4++) {
+        const Q4 = 1 / (y2 * C4 + g4), i4 = (a3 * C4 + A4) * Q4, E4 = (r2 * C4 + I4) * Q4, e4 = i4 < 0 ? 0 : i4 > u2 ? u2 : i4, n4 = E4 < 0 ? 0 : E4 > m2 ? m2 : E4, s3 = 0 | e4, c3 = 0 | n4, h3 = s3 < u2 ? s3 + 1 : s3, l3 = c3 < m2 ? c3 + 1 : c3, D3 = e4 - s3, w3 = n4 - c3, d3 = 1 - D3, R2 = 1 - w3, p2 = d3 * R2, F2 = D3 * R2, J2 = d3 * w3, G2 = D3 * w3, k2 = c3 * t3 + s3 << 2, S2 = c3 * t3 + h3 << 2, M2 = l3 * t3 + s3 << 2, b = l3 * t3 + h3 << 2, L = N2 * B3 + C4 << 2;
+        f2[L] = o3[k2] * p2 + o3[S2] * F2 + o3[M2] * J2 + o3[b] * G2 + 0.5 | 0, f2[L + 1] = o3[k2 + 1] * p2 + o3[S2 + 1] * F2 + o3[M2 + 1] * J2 + o3[b + 1] * G2 + 0.5 | 0, f2[L + 2] = o3[k2 + 2] * p2 + o3[S2 + 2] * F2 + o3[M2 + 2] * J2 + o3[b + 2] * G2 + 0.5 | 0, f2[L + 3] = 255;
+      }
+    }
+    A3.putImageData(d2, 0, 0);
+  })(A2, I2, (function(A3, I3) {
+    const g3 = (function(A4, I4) {
+      const g4 = A4.length, B3 = A4[0].length, C3 = A4.map((A5) => A5.slice()), Q3 = I4.slice();
+      for (let i3 = 0; i3 < B3; i3++) {
+        let A5 = i3;
+        for (let I5 = i3 + 1; I5 < g4; I5++) Math.abs(C3[I5][i3]) > Math.abs(C3[A5][i3]) && (A5 = I5);
+        [C3[i3], C3[A5]] = [C3[A5], C3[i3]], [Q3[i3], Q3[A5]] = [Q3[A5], Q3[i3]];
+        for (let I5 = i3 + 1; I5 < g4; I5++) {
+          const A6 = C3[I5][i3] / C3[i3][i3];
+          for (let g5 = i3; g5 < B3; g5++) C3[I5][g5] -= A6 * C3[i3][g5];
+          Q3[I5] -= A6 * Q3[i3];
+        }
+      }
+      const t3 = new Array(B3);
+      for (let i3 = B3 - 1; i3 >= 0; i3--) {
+        let A5 = Q3[i3];
+        for (let I5 = i3 + 1; I5 < B3; I5++) A5 -= C3[i3][I5] * t3[I5];
+        t3[i3] = A5 / C3[i3][i3];
+      }
+      return t3;
+    })((function(A4) {
+      const g4 = [];
+      for (let B3 = 0; B3 < 4; B3++) {
+        const [C3, Q3] = A4[B3];
+        g4.push([C3, Q3, 1, 0, 0, 0, -C3 * I3[B3][0], -Q3 * I3[B3][0]]), g4.push([0, 0, 0, C3, Q3, 1, -C3 * I3[B3][1], -Q3 * I3[B3][1]]);
+      }
+      return g4;
+    })(A3), [I3[0][0], I3[0][1], I3[1][0], I3[1][1], I3[2][0], I3[2][1], I3[3][0], I3[3][1]]);
+    return [[g3[0], g3[1], g3[2]], [g3[3], g3[4], g3[5]], [g3[6], g3[7], 1]];
+  })([[B2.x, B2.y], [C2.x, C2.y], [Q2.x, Q2.y], [t2.x, t2.y]], [[0, 0], [e2 - 1, 0], [e2 - 1, a2 - 1], [0, a2 - 1]]), e2, a2);
+}
+async function IA(A2, I2 = {}) {
+  const g2 = [], B2 = performance.now(), C2 = I2.mode || "detect", Q2 = I2.output || "canvas", t2 = I2.maxProcessingDimension || 800;
+  let i2, E2, e2, o2;
+  if ("ml" === (I2.detector || "classical")) {
+    E2 = performance.now();
+    const { detectDocumentMl: B3 } = await Promise.resolve().then(() => (init_scanic_ml_stub(), scanic_ml_stub_exports));
+    i2 = await B3(A2, I2.ml || {}), g2.push({ step: "ML Detection Total", ms: (performance.now() - E2).toFixed(2) }), i2.timings && i2.timings.forEach((A3) => g2.push(A3));
+  } else {
+    E2 = performance.now();
+    const { grayscaleData: B3, scaleFactor: C3, scaledDimensions: Q3 } = await (async function(A3, I3 = 800) {
+      let g3, B4;
+      const C4 = A3 && "number" == typeof A3.width && "number" == typeof A3.height && A3.data;
+      if (C4) g3 = A3.width, B4 = A3.height;
+      else {
+        if (!A3) throw new Error("No image provided");
+        g3 = A3.width || A3.naturalWidth, B4 = A3.height || A3.naturalHeight;
+      }
+      const Q4 = Math.max(g3, B4);
+      let t3, i3, E3;
+      if (Q4 <= I3) t3 = g3, i3 = B4, E3 = 1;
+      else {
+        const A4 = I3 / Q4;
+        t3 = Math.round(g3 * A4), i3 = Math.round(B4 * A4), E3 = 1 / A4;
+      }
+      const e3 = "undefined" != typeof OffscreenCanvas, o3 = e3 ? new OffscreenCanvas(t3, i3) : document.createElement("canvas");
+      e3 || (o3.width = t3, o3.height = i3);
+      const n3 = o3.getContext("2d", { willReadFrequently: true });
+      if (n3.imageSmoothingEnabled = true, n3.imageSmoothingQuality = "medium", C4) {
+        const I4 = e3 ? new OffscreenCanvas(g3, B4) : document.createElement("canvas");
+        e3 || (I4.width = g3, I4.height = B4), I4.getContext("2d").putImageData(A3, 0, 0), n3.drawImage(I4, 0, 0, g3, B4, 0, 0, t3, i3);
+      } else n3.drawImage(A3, 0, 0, g3, B4, 0, 0, t3, i3);
+      const a2 = n3.getImageData(0, 0, t3, i3), s2 = a2.data, c2 = new Uint8ClampedArray(t3 * i3);
+      for (let r2 = 0, h2 = 0; r2 < s2.length; r2 += 4, h2++) {
+        const A4 = 54 * s2[r2] + 183 * s2[r2 + 1] + 19 * s2[r2 + 2] >> 8;
+        c2[h2] = A4, s2[r2] = s2[r2 + 1] = s2[r2 + 2] = A4;
+      }
+      return { grayscaleData: c2, imageData: a2, scaleFactor: E3, originalDimensions: { width: g3, height: B4 }, scaledDimensions: { width: t3, height: i3 } };
+    })(A2, t2);
+    g2.push({ step: "Image Prep + Scale + Gray", ms: (performance.now() - E2).toFixed(2) }), i2 = await _(B3, Q3.width, Q3.height, C3, I2), i2.timings && i2.timings.forEach((A3) => g2.push(A3));
+  }
+  if (!i2.success) {
+    const A3 = performance.now();
+    return g2.unshift({ step: "Total", ms: (A3 - B2).toFixed(2) }), { output: null, corners: null, contour: null, confidence: i2.confidence || null, score: i2.score ?? null, debug: i2.debug, success: false, message: i2.message || "No document detected", timings: g2 };
+  }
+  "detect" === C2 ? o2 = null : "extract" === C2 && (E2 = performance.now(), e2 = document.createElement("canvas"), $(e2.getContext("2d"), A2, i2.corners), g2.push({ step: "Perspective Transform", ms: (performance.now() - E2).toFixed(2) })), "detect" !== C2 && e2 && (E2 = performance.now(), o2 = "canvas" === Q2 ? e2 : "imagedata" === Q2 ? e2.getContext("2d").getImageData(0, 0, e2.width, e2.height) : "dataurl" === Q2 ? e2.toDataURL() : e2, g2.push({ step: "Output Conversion", ms: (performance.now() - E2).toFixed(2) }));
+  const n2 = performance.now();
+  return g2.unshift({ step: "Total", ms: (n2 - B2).toFixed(2) }), { output: o2, corners: i2.corners, contour: i2.contour ?? null, confidence: i2.confidence || null, score: i2.score ?? null, debug: i2.debug, success: true, message: "Document detected", timings: g2 };
+}
+var A, I, g, s, r, y, d, N, R, p;
+var init_scanic = __esm({
+  "vendor/scanic/scanic.js"() {
+    "use strict";
+    I = 1e3;
+    g = 10;
+    s = null;
+    r = 0;
+    y = null;
+    d = null;
+    N = null;
+    R = false;
+    p = null;
+  }
+});
+
+// src/core/doc/detector-scanic.ts
+var detector_scanic_exports = {};
+__export(detector_scanic_exports, {
+  DOC_DETECT_MIN_CONFIDENCE: () => DOC_DETECT_MIN_CONFIDENCE,
+  DOC_DETECT_WIDTH: () => DOC_DETECT_WIDTH,
+  SCANIC_VERSION: () => SCANIC_VERSION,
+  detectQuad: () => detectQuad
+});
+async function detectQuad(image) {
+  const result = await IA(image, {
+    mode: "detect",
+    detector: "classical",
+    maxProcessingDimension: DOC_DETECT_WIDTH
+  });
+  if (!result.success || result.corners === null) return null;
+  if (typeof result.confidence === "number" && result.confidence < DOC_DETECT_MIN_CONFIDENCE) {
+    return null;
+  }
+  return result.corners;
+}
+var SCANIC_VERSION, DOC_DETECT_MIN_CONFIDENCE;
+var init_detector_scanic = __esm({
+  "src/core/doc/detector-scanic.ts"() {
+    "use strict";
+    init_scanic();
+    init_doc_gate_v1();
+    SCANIC_VERSION = "1.5.0";
+    DOC_DETECT_MIN_CONFIDENCE = 0.35;
+  }
+});
+
+// src/internal/index.ts
+var internal_exports = {};
+__export(internal_exports, {
+  ASPECT_BANDS: () => ASPECT_BANDS,
+  AttestationError: () => AttestationError,
+  CAPTURE_CANDIDATE_SPACING_MS: () => CAPTURE_CANDIDATE_SPACING_MS,
+  CAPTURE_EXTRA_CANDIDATES: () => CAPTURE_EXTRA_CANDIDATES,
+  CENTERED_FACTOR: () => CENTERED_FACTOR,
+  CIRCLE_RADIUS_FACTOR: () => CIRCLE_RADIUS_FACTOR,
+  CLIP_MIME_ALLOWLIST: () => CLIP_MIME_ALLOWLIST,
+  CaptureSessionDoc: () => CaptureSessionDoc,
+  DOC_ANALYSIS_DEFAULTS: () => DOC_ANALYSIS_DEFAULTS,
+  DOC_CADENCE_HZ: () => DOC_CADENCE_HZ,
+  DOC_DETECT_WIDTH: () => DOC_DETECT_WIDTH,
+  DOC_FEEDBACK_STATES: () => DOC_FEEDBACK_STATES,
+  DOC_GATE_V1_DEFAULTS: () => DOC_GATE_V1_DEFAULTS,
+  DocFeedbackAggregator: () => DocFeedbackAggregator,
+  DocGateV1: () => DocGateV1,
+  IN_CIRCLE_FACTOR: () => IN_CIRCLE_FACTOR,
+  MRZ_BAND_DEFAULTS: () => MRZ_BAND_DEFAULTS,
+  MR_DOC_CATALOG: () => MR_DOC_CATALOG,
+  PROCESSING_POLL_DELAY_MS: () => PROCESSING_POLL_DELAY_MS,
+  PROCESSING_POLL_MAX: () => PROCESSING_POLL_MAX,
+  REGISTRY_RETRY_DELAY_MS: () => REGISTRY_RETRY_DELAY_MS,
+  RETRYABLE_REASONS: () => RETRYABLE_REASONS,
+  TRANSPORT_REPLAY_ATTEMPTS: () => TRANSPORT_REPLAY_ATTEMPTS,
+  TRANSPORT_REPLAY_DELAY_MS: () => TRANSPORT_REPLAY_DELAY_MS,
+  TURNSTILE_EXECUTE_TIMEOUT_MS: () => TURNSTILE_EXECUTE_TIMEOUT_MS,
+  TURNSTILE_SCRIPT_SRC: () => TURNSTILE_SCRIPT_SRC,
+  analyzeDocFrame: () => analyzeDocFrame,
+  aspectBand: () => aspectBand,
+  createLivenessCaptureInternal: () => createLivenessCaptureInternal,
+  createVerificationInternal: () => createVerificationInternal,
+  detectMrzBand: () => detectMrzBand,
+  executeTurnstile: () => executeTurnstile,
+  feedbackVoteOf: () => feedbackVoteOf,
+  frontierStep: () => frontierStep,
+  isExecutable: () => isExecutable,
+  isTerminalView: () => isTerminalView,
+  loadTurnstile: () => loadTurnstile,
+  mapEngineState: () => mapEngineState,
+  mapErrorKind: () => mapErrorKind,
+  mapGuidanceHint: () => mapGuidanceHint,
+  mapSessionResult: () => mapSessionResult,
+  mergeSessionView: () => mergeSessionView,
+  quadAreaFrac: () => quadAreaFrac,
+  quadBounds: () => quadBounds,
+  quadIou: () => quadIou,
+  quadTiltRatio: () => quadTiltRatio,
+  randomUuid: () => randomUuid,
+  resetTurnstileForTests: () => resetTurnstileForTests,
+  runLivenessFlow: () => runLivenessFlow,
+  runSubmission: () => runSubmission,
+  specularFraction: () => specularFraction,
+  stepOf: () => stepOf,
+  warmDocDetector: () => warmDocDetector
+});
+module.exports = __toCommonJS(internal_exports);
+init_doc_catalog();
+init_doc_gate_v1();
+
+// src/core/doc/mrz-band.ts
+var MRZ_BAND_DEFAULTS = Object.freeze({
+  EDGE_LUMA_DELTA: 40,
+  MIN_ROW_DENSITY: 0.08,
+  MIN_COLUMN_COVERAGE: 0.6,
+  MIN_WIDTH_FRAC: 0.55,
+  MIN_HEIGHT_FRAC: 0.02,
+  MAX_HEIGHT_FRAC: 0.16,
+  ROW_MERGE_GAP: 18
+});
+var COLUMN_BUCKETS = 12;
+function detectMrzBand(frame, overrides = {}) {
+  const t2 = { ...MRZ_BAND_DEFAULTS, ...overrides };
+  const { data, width, height } = frame;
+  if (width < 32 || height < 32) return null;
+  const qualifies = new Array(height).fill(false);
+  const density = new Float32Array(height);
+  const minX = new Int32Array(height).fill(width);
+  const maxX = new Int32Array(height).fill(-1);
+  const bucketWidth = width / COLUMN_BUCKETS;
+  const buckets = new Array(COLUMN_BUCKETS);
+  for (let y2 = 0; y2 < height; y2++) {
+    let edges = 0;
+    buckets.fill(false);
+    const rowOffset = y2 * width * 4;
+    let previousLuma = 0.299 * (data[rowOffset] ?? 0) + 0.587 * (data[rowOffset + 1] ?? 0) + 0.114 * (data[rowOffset + 2] ?? 0);
+    for (let x = 1; x < width; x++) {
+      const i2 = rowOffset + x * 4;
+      const luma = 0.299 * (data[i2] ?? 0) + 0.587 * (data[i2 + 1] ?? 0) + 0.114 * (data[i2 + 2] ?? 0);
+      if (Math.abs(luma - previousLuma) >= t2.EDGE_LUMA_DELTA) {
+        edges += 1;
+        buckets[Math.min(COLUMN_BUCKETS - 1, Math.floor(x / bucketWidth))] = true;
+        if (x < minX[y2]) minX[y2] = x;
+        if (x > maxX[y2]) maxX[y2] = x;
+      }
+      previousLuma = luma;
+    }
+    density[y2] = edges / width;
+    const coverage = buckets.filter(Boolean).length / COLUMN_BUCKETS;
+    qualifies[y2] = density[y2] >= t2.MIN_ROW_DENSITY && coverage >= t2.MIN_COLUMN_COVERAGE && maxX[y2] - minX[y2] >= t2.MIN_WIDTH_FRAC * width;
+  }
+  let best = null;
+  let runTop = -1;
+  let lastQualifying = -1;
+  let runRows = 0;
+  const flush = (bottom) => {
+    if (runTop < 0) return;
+    const bandHeight = bottom - runTop + 1;
+    if (bandHeight >= t2.MIN_HEIGHT_FRAC * height && bandHeight <= t2.MAX_HEIGHT_FRAC * height && runRows >= 4 && // at least a few real stroke rows, not a lone edge
+    (best === null || runRows > best.rows)) {
+      best = { top: runTop, bottom, rows: runRows };
+    }
+    runTop = -1;
+    runRows = 0;
+  };
+  for (let y2 = 0; y2 < height; y2++) {
+    if (qualifies[y2]) {
+      if (runTop < 0) runTop = y2;
+      else if (y2 - lastQualifying > t2.ROW_MERGE_GAP) {
+        flush(lastQualifying);
+        runTop = y2;
+      }
+      lastQualifying = y2;
+      runRows += 1;
+    }
+  }
+  flush(lastQualifying);
+  if (best === null) return null;
+  const band = best;
+  let x1 = width;
+  let x2 = -1;
+  let densitySum = 0;
+  let densityRows = 0;
+  for (let y2 = band.top; y2 <= band.bottom; y2++) {
+    if (!qualifies[y2]) continue;
+    if (minX[y2] < x1) x1 = minX[y2];
+    if (maxX[y2] > x2) x2 = maxX[y2];
+    densitySum += density[y2];
+    densityRows += 1;
+  }
+  if (x2 - x1 < t2.MIN_WIDTH_FRAC * width) return null;
+  return {
+    x: x1,
+    y: band.top,
+    width: x2 - x1,
+    height: band.bottom - band.top + 1,
+    density: densityRows > 0 ? densitySum / densityRows : 0
+  };
+}
+
+// src/core/doc/frame-analysis.ts
+init_frame_quality();
+init_doc_catalog();
+init_doc_gate_v1();
+var DOC_ANALYSIS_DEFAULTS = Object.freeze({
+  /** Doc area fraction above which the camera is too close (capture would crop). */
+  MAX_AREA_FRAC: 0.92,
+  /** Opposite-side length ratio beyond which the view is too oblique. */
+  TILT_MAX_SIDE_RATIO: 1.3,
+  /** Specular-pixel fraction at/above which the frame reads as glare. */
+  GLARE_MAX_SPECULAR_FRAC: 0.025
+});
+function specularFraction(crop) {
+  const { data, width, height } = crop;
+  const pixels = width * height;
+  if (pixels === 0) return 0;
+  let hot = 0;
+  for (let i2 = 0; i2 < pixels; i2++) {
+    const o2 = i2 * 4;
+    const luma = 0.299 * (data[o2] ?? 0) + 0.587 * (data[o2 + 1] ?? 0) + 0.114 * (data[o2 + 2] ?? 0);
+    if (luma >= 252) hot++;
+  }
+  return hot / pixels;
+}
+function quadTiltRatio(quad) {
+  const len = (a2, b) => Math.hypot(b.x - a2.x, b.y - a2.y);
+  const top = len(quad.topLeft, quad.topRight);
+  const bottom = len(quad.bottomLeft, quad.bottomRight);
+  const left = len(quad.topLeft, quad.bottomLeft);
+  const right = len(quad.topRight, quad.bottomRight);
+  const h2 = Math.max(top, bottom) / Math.max(1e-6, Math.min(top, bottom));
+  const v = Math.max(left, right) / Math.max(1e-6, Math.min(left, right));
+  return Math.max(h2, v);
+}
+function analyzeDocFrame(input) {
+  const t2 = { ...DOC_GATE_V1_DEFAULTS, ...input.thresholds };
+  const a2 = DOC_ANALYSIS_DEFAULTS;
+  const { quad, frameWidth, frameHeight, measures } = input;
+  const bandMode = input.format === "ID-3";
+  let framing = "ok";
+  if (quad === null) {
+    framing = "no_document";
+  } else if (bandMode) {
+    const bounds = quadBounds(quad);
+    const widthFrac = frameWidth > 0 ? bounds.width / frameWidth : 0;
+    const aspect = bounds.height > 0 ? bounds.width / bounds.height : 0;
+    if (widthFrac < t2.ID3_BAND_MIN_WIDTH_FRAC) framing = "too_far";
+    else if (edgeClipped(quad, frameWidth, frameHeight, t2.EDGE_CLIP_MARGIN_PX)) {
+      framing = "edge_clipped";
+    } else if (aspect < t2.ID3_BAND_ASPECT_MIN || aspect > t2.ID3_BAND_ASPECT_MAX) {
+      framing = "wrong_shape";
+    }
+  } else {
+    const areaFrac = quadAreaFrac(quad, frameWidth, frameHeight);
+    const band = aspectBand(input.format);
+    const bounds = quadBounds(quad);
+    const aspect = Math.max(bounds.width, bounds.height) / Math.max(1e-6, Math.min(bounds.width, bounds.height));
+    if (areaFrac < t2.MIN_AREA_FRAC) framing = "too_far";
+    else if (areaFrac > a2.MAX_AREA_FRAC) framing = "too_close";
+    else if (edgeClipped(quad, frameWidth, frameHeight, t2.EDGE_CLIP_MARGIN_PX)) {
+      framing = "edge_clipped";
+    } else if (Math.abs(aspect - band.center) > band.tolerance) framing = "wrong_shape";
+    else if (quadTiltRatio(quad) > a2.TILT_MAX_SIDE_RATIO) framing = "tilted";
+  }
+  const lighting = measures.exposure >= t2.GUIDE_EXPOSURE ? "ok" : measures.meanLuma < (EXPOSURE_BAND[0] + EXPOSURE_BAND[1]) / 2 ? "too_dark" : "too_bright";
+  const blur = measures.sharpness >= t2.GUIDE_SHARPNESS ? "ok" : "blurry";
+  const glare = measures.specularFraction >= a2.GLARE_MAX_SPECULAR_FRAC ? "glare" : "ok";
+  return {
+    framing,
+    lighting,
+    blur,
+    glare,
+    acceptable: framing === "ok" && lighting === "ok" && blur === "ok" && glare === "ok"
+  };
+}
+function edgeClipped(quad, frameWidth, frameHeight, margin) {
+  const pts = [quad.topLeft, quad.topRight, quad.bottomRight, quad.bottomLeft];
+  return pts.some(
+    (p2) => p2.x <= margin || p2.y <= margin || p2.x >= frameWidth - margin || p2.y >= frameHeight - margin
+  );
+}
+
+// src/core/doc/feedback-aggregator.ts
+var DOC_FEEDBACK_STATES = Object.freeze({
+  sensing: { key: "sensing", reticle: "searching", minDurationMs: 900 },
+  too_far: { key: "too_far", reticle: "coaching", minDurationMs: 1400 },
+  too_close: { key: "too_close", reticle: "coaching", minDurationMs: 1400 },
+  edge_clipped: { key: "edge_clipped", reticle: "coaching", minDurationMs: 1400 },
+  wrong_shape: { key: "wrong_shape", reticle: "coaching", minDurationMs: 1400 },
+  tilted: { key: "tilted", reticle: "coaching", minDurationMs: 1400 },
+  too_dark: { key: "too_dark", reticle: "coaching", minDurationMs: 1400 },
+  too_bright: { key: "too_bright", reticle: "coaching", minDurationMs: 1400 },
+  blurry: { key: "blurry", reticle: "coaching", minDurationMs: 1400 },
+  glare: { key: "glare", reticle: "coaching", minDurationMs: 1400 },
+  hold_still: { key: "hold_still", reticle: "locking", minDurationMs: 900 },
+  processing: { key: "processing", reticle: "processing", minDurationMs: 800 },
+  side_captured: { key: "side_captured", reticle: "flip", minDurationMs: 2600 },
+  captured: { key: "captured", reticle: "done", minDurationMs: 800 }
+});
+function feedbackVoteOf(analysis) {
+  if (analysis.framing === "no_document") return "sensing";
+  if (analysis.framing === "too_far") return "too_far";
+  if (analysis.framing === "too_close") return "too_close";
+  if (analysis.framing === "edge_clipped") return "edge_clipped";
+  if (analysis.framing === "wrong_shape") return "wrong_shape";
+  if (analysis.framing === "tilted") return "tilted";
+  if (analysis.lighting === "too_dark") return "too_dark";
+  if (analysis.lighting === "too_bright") return "too_bright";
+  if (analysis.glare === "glare") return "glare";
+  if (analysis.blur === "blurry") return "blurry";
+  return "hold_still";
+}
+var DocFeedbackAggregator = class {
+  constructor(windowMs = 2600, decayPerSecond = 0.35) {
+    this.windowMs = windowMs;
+    this.decayPerSecond = decayPerSecond;
+    this.votes = [];
+    this.current = DOC_FEEDBACK_STATES.sensing;
+    this.currentSinceMs = null;
+  }
+  reset() {
+    this.votes = [];
+    this.current = DOC_FEEDBACK_STATES.sensing;
+    this.currentSinceMs = null;
+  }
+  /** Force a terminal/choreography state (capture fired, side flip, upload). */
+  force(key, nowMs) {
+    this.votes = [];
+    this.current = DOC_FEEDBACK_STATES[key];
+    this.currentSinceMs = nowMs;
+    return this.current;
+  }
+  /** Cast this frame's vote and return the (possibly held) winning state. */
+  tick(vote, nowMs) {
+    if (this.currentSinceMs === null) this.currentSinceMs = nowMs;
+    this.votes.push({ key: vote, atMs: nowMs });
+    this.votes = this.votes.filter((v) => nowMs - v.atMs <= this.windowMs);
+    if (nowMs - this.currentSinceMs < this.current.minDurationMs) return this.current;
+    const scores = /* @__PURE__ */ new Map();
+    for (const v of this.votes) {
+      const ageSeconds = (nowMs - v.atMs) / 1e3;
+      const weight = this.decayPerSecond ** ageSeconds;
+      scores.set(v.key, (scores.get(v.key) ?? 0) + weight);
+    }
+    let winner = this.current.key;
+    let best = -1;
+    for (const [key, score] of scores) {
+      if (score > best) {
+        best = score;
+        winner = key;
+      }
+    }
+    if (winner !== this.current.key) {
+      this.current = DOC_FEEDBACK_STATES[winner];
+      this.currentSinceMs = nowMs;
+    }
+    return this.current;
+  }
+};
+
+// 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((t2) => MR.isTypeSupported(t2)) ?? "";
+}
+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 w2 = globalThis;
+  if (typeof w2.window !== "undefined" && w2.window.isSecureContext === false)
+    return "INSECURE_CONTEXT";
+  const md = w2.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/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/doc/capture-session-doc.ts
+init_frame_quality();
+init_doc_gate_v1();
+var scanicDetect = null;
+async function lazyScanicDetect(image) {
+  if (scanicDetect === null) {
+    const module_ = await Promise.resolve().then(() => (init_detector_scanic(), detector_scanic_exports));
+    scanicDetect = module_.detectQuad;
+  }
+  return scanicDetect(image);
+}
+async function mrzBandDetect(image) {
+  const band = detectMrzBand(image);
+  if (band === null) return null;
+  return {
+    topLeft: { x: band.x, y: band.y },
+    topRight: { x: band.x + band.width, y: band.y },
+    bottomRight: { x: band.x + band.width, y: band.y + band.height },
+    bottomLeft: { x: band.x, y: band.y + band.height }
+  };
+}
+function warmDocDetector() {
+  if (scanicDetect !== null) return;
+  void Promise.resolve().then(() => (init_detector_scanic(), detector_scanic_exports)).then((module_) => {
+    scanicDetect = module_.detectQuad;
+  }).catch(() => void 0);
+}
+var DOC_CADENCE_HZ = Object.freeze({
+  LOW: 3,
+  MID: 5,
+  HIGH: 6
+});
+var CaptureSessionDoc = class {
+  constructor(opts) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.stream = null;
+    this.timer = null;
+    this.state = "idle";
+    this.lastGuidance = null;
+    this.attempt = 0;
+    this.capturing = false;
+    this.feedback = new DocFeedbackAggregator();
+    this.lastFeedbackKey = null;
+    this.opts = opts;
+    this.gate = new DocGateV1(opts.format ?? "ID-1", opts.thresholds);
+    const deviceClass = opts.deviceClass ?? classifyDevice(probeDevice());
+    this.cadenceMs = 1e3 / DOC_CADENCE_HZ[deviceClass];
+  }
+  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() {
+    const attempt = ++this.attempt;
+    this.gate.reset();
+    this.feedback.reset();
+    this.lastFeedbackKey = null;
+    this.lastGuidance = null;
+    this.capturing = false;
+    this.setState("preflight");
+    try {
+      const getUserMedia = this.opts.getUserMedia ?? ((constraints) => navigator.mediaDevices.getUserMedia(constraints));
+      this.setState("acquiring");
+      this.stream = await getUserMedia({
+        audio: false,
+        video: {
+          facingMode: { ideal: "environment" },
+          width: { ideal: 1920 },
+          height: { ideal: 1080 }
+        }
+      });
+      if (attempt !== this.attempt) {
+        for (const track of this.stream.getTracks()) track.stop();
+        return;
+      }
+      this.opts.video.srcObject = this.stream;
+      await this.opts.video.play().catch(() => void 0);
+      this.setState("positioning");
+      this.scheduleTick(attempt);
+    } catch (err) {
+      const kind = mapGetUserMediaError(err);
+      this.setState("error");
+      this.emit("error", { kind, retryable: true });
+    }
+  }
+  /** Restart the gate for another side / a retake (same stream). */
+  rearm(side) {
+    if (side !== void 0) this.opts.side = side;
+    this.gate.reset();
+    this.feedback.reset();
+    this.lastFeedbackKey = null;
+    this.lastGuidance = null;
+    this.capturing = false;
+    if (this.state === "captured") {
+      this.setState("positioning");
+      this.scheduleTick(this.attempt);
+    }
+  }
+  destroy() {
+    this.attempt += 1;
+    if (this.timer !== null) (this.opts.clearTimer ?? clearTimeout)(this.timer);
+    this.timer = null;
+    if (this.stream) for (const track of this.stream.getTracks()) track.stop();
+    this.stream = null;
+    this.opts.video.srcObject = null;
+  }
+  setState(state) {
+    this.state = state;
+    this.emit("statechange", { state });
+  }
+  scheduleTick(attempt) {
+    const setTimer = this.opts.setTimer ?? setTimeout;
+    this.timer = setTimer(() => void this.tick(attempt), this.cadenceMs);
+  }
+  async tick(attempt) {
+    if (attempt !== this.attempt || this.state !== "positioning" || this.capturing) return;
+    const now = this.opts.now ?? (() => performance.now());
+    const grab = this.opts.grabDetectFrame ?? defaultGrabDetectFrame;
+    const detect = this.opts.detect ?? ((this.opts.format ?? "ID-1") === "ID-3" ? mrzBandDetect : lazyScanicDetect);
+    const frame = grab(this.opts.video, DOC_DETECT_WIDTH);
+    if (frame === null) {
+      this.scheduleTick(attempt);
+      return;
+    }
+    let quad = null;
+    try {
+      quad = await detect(frame);
+    } catch {
+      quad = null;
+    }
+    if (attempt !== this.attempt) return;
+    const crop = quad !== null ? cropQuadRegion(frame, quad) : frame;
+    const atMs = now();
+    const measures = {
+      sharpness: sharpness(crop),
+      exposure: exposure(crop),
+      meanLuma: meanLuma(crop),
+      specularFraction: specularFraction(crop)
+    };
+    const analysis = analyzeDocFrame({
+      format: this.opts.format ?? "ID-1",
+      quad,
+      frameWidth: frame.width,
+      frameHeight: frame.height,
+      measures,
+      ...this.opts.thresholds !== void 0 ? { thresholds: this.opts.thresholds } : {}
+    });
+    const tick = this.gate.tick({
+      timestampMs: atMs,
+      quad,
+      quality: measures,
+      frameWidth: frame.width,
+      frameHeight: frame.height
+    });
+    this.emit("checks", {
+      engine: "docv1",
+      p: tick.p,
+      plausible: tick.plausible,
+      stableTicks: tick.stableTicks,
+      quad: tick.quad,
+      frameWidth: frame.width,
+      frameHeight: frame.height,
+      analysis
+    });
+    const feedbackState = this.feedback.tick(feedbackVoteOf(analysis), atMs);
+    if (feedbackState.key !== this.lastFeedbackKey) {
+      this.lastFeedbackKey = feedbackState.key;
+      this.emit("feedback", feedbackState);
+    }
+    if (tick.guidanceKey !== this.lastGuidance) {
+      this.lastGuidance = tick.guidanceKey;
+      this.emit("guidance", { key: tick.guidanceKey });
+    }
+    if (tick.ready && quad !== null) {
+      const processing = this.feedback.force("processing", atMs);
+      this.lastFeedbackKey = processing.key;
+      this.emit("feedback", processing);
+      await this.fire(attempt, quad, {
+        width: frame.width,
+        height: frame.height,
+        tickSharpness: measures.sharpness
+      });
+      return;
+    }
+    this.scheduleTick(attempt);
+  }
+  /**
+   * BEST-FRAME capture window (capture-v2): the first ready tick captures a
+   * candidate immediately, then up to CAPTURE_EXTRA_CANDIDATES more stills are
+   * taken at CAPTURE_CANDIDATE_SPACING_MS while the user holds — each scored
+   * by the live detect-tick sharpness at its capture moment — and the SHARPEST
+   * wins. Beats first-acceptable-frame capture without decoding stills.
+   */
+  async fire(attempt, quad, detectSize) {
+    this.capturing = true;
+    const capture = this.opts.captureStill ?? defaultCaptureStill;
+    const grab = this.opts.grabDetectFrame ?? defaultGrabDetectFrame;
+    const setTimer = this.opts.setTimer ?? setTimeout;
+    const size = { width: detectSize.width, height: detectSize.height };
+    try {
+      let best = {
+        still: await capture(this.opts.video, quad, size),
+        sharpness: detectSize.tickSharpness
+      };
+      for (let i2 = 0; i2 < CAPTURE_EXTRA_CANDIDATES; i2++) {
+        await new Promise((resolve) => {
+          setTimer(() => resolve(), CAPTURE_CANDIDATE_SPACING_MS);
+        });
+        if (attempt !== this.attempt) return;
+        const frame = grab(this.opts.video, DOC_DETECT_WIDTH);
+        if (frame === null) continue;
+        const candidateSharpness = sharpness(cropQuadRegion(frame, quad));
+        if (candidateSharpness > best.sharpness * CAPTURE_IMPROVEMENT_MIN_RATIO) {
+          const still = await capture(this.opts.video, quad, size);
+          if (attempt !== this.attempt) return;
+          best = { still, sharpness: candidateSharpness };
+        }
+      }
+      if (attempt !== this.attempt) return;
+      this.setState("captured");
+      this.emit("artifacts", {
+        keyframe: best.still.blob,
+        previewDataUrl: best.still.previewDataUrl,
+        ...this.opts.side !== void 0 ? { side: this.opts.side } : {}
+      });
+    } catch {
+      if (attempt !== this.attempt) return;
+      this.capturing = false;
+      this.gate.reset();
+      this.scheduleTick(attempt);
+    }
+  }
+};
+var CAPTURE_EXTRA_CANDIDATES = 2;
+var CAPTURE_CANDIDATE_SPACING_MS = 260;
+var CAPTURE_IMPROVEMENT_MIN_RATIO = 1.08;
+function defaultGrabDetectFrame(video, targetWidth) {
+  const vw = video.videoWidth;
+  const vh = video.videoHeight;
+  if (vw === 0 || vh === 0) return null;
+  const scale = Math.min(1, targetWidth / vw);
+  const width = Math.round(vw * scale);
+  const height = Math.round(vh * scale);
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (context === null) return null;
+  context.drawImage(video, 0, 0, width, height);
+  return context.getImageData(0, 0, width, height);
+}
+async function defaultCaptureStill(video, _quad, _detectSize) {
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.max(1, video.videoWidth);
+  canvas.height = Math.max(1, video.videoHeight);
+  const context = canvas.getContext("2d");
+  if (context === null) throw new Error("2d context unavailable");
+  context.drawImage(video, 0, 0, canvas.width, canvas.height);
+  const blob = await new Promise((resolve, reject) => {
+    canvas.toBlob((b) => b ? resolve(b) : reject(new Error("toBlob failed")), "image/jpeg", 0.92);
+  });
+  return { blob, previewDataUrl: canvas.toDataURL("image/jpeg", 0.85) };
+}
+function cropQuadRegion(frame, quad) {
+  const xs = [quad.topLeft.x, quad.topRight.x, quad.bottomRight.x, quad.bottomLeft.x];
+  const ys = [quad.topLeft.y, quad.topRight.y, quad.bottomRight.y, quad.bottomLeft.y];
+  const x1 = Math.max(0, Math.floor(Math.min(...xs)));
+  const y1 = Math.max(0, Math.floor(Math.min(...ys)));
+  const x2 = Math.min(frame.width, Math.ceil(Math.max(...xs)));
+  const y2 = Math.min(frame.height, Math.ceil(Math.max(...ys)));
+  const width = Math.max(1, x2 - x1);
+  const height = Math.max(1, y2 - y1);
+  const data = new Uint8ClampedArray(width * height * 4);
+  for (let row = 0; row < height; row++) {
+    const src = ((y1 + row) * frame.width + x1) * 4;
+    data.set(frame.data.subarray(src, src + width * 4), row * width * 4);
+  }
+  return { data, width, height, colorSpace: frame.colorSpace };
+}
+
+// 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/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 = (e2) => {
+        if (e2.data && e2.data.size) {
+          this.chunks.push(e2.data);
+          this.bytes += e2.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 s2 = stream ?? this.stream;
+    s2?.getTracks().forEach((t2) => t2.stop());
+    this.stream = null;
+  }
+};
+
+// src/core/keyframe.ts
+function captureMirroredKeyframe(video, canvas, quality = 0.92) {
+  return new Promise((resolve, reject) => {
+    const w2 = video.videoWidth;
+    const h2 = video.videoHeight;
+    if (!w2 || !h2) {
+      reject(new Error("video-not-ready"));
+      return;
+    }
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      reject(new Error("no-2d-context"));
+      return;
+    }
+    canvas.width = w2;
+    canvas.height = h2;
+    ctx.scale(-1, 1);
+    ctx.drawImage(video, -w2, 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 a2 = keypoints?.[0];
+  const b = keypoints?.[1];
+  if (a2 === void 0 || b === void 0) return void 0;
+  const toSource = (p2) => ({ x: p2.x * size.width, y: p2.y * size.height });
+  const [pa, pb] = [toSource(a2), 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 [a2, b] = eyePoints;
+  if (a2 === void 0 || b === void 0) return void 0;
+  return a2.x <= b.x ? { left: a2, right: b } : { left: b, right: a2 };
+}
+
+// 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 = (p2) => ({ x: p2.x * scaleX, y: p2.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/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
+init_frame_quality();
+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 clamp012 = (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: clamp012(quality.sharpness),
+      exposure: clamp012(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 = clamp012(
+      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((_2, 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 - clamp012(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 - clamp012(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 - clamp012(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
+init_frame_quality();
+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 i2 = 0; i2 < KEYFRAME_CANDIDATES; i2 += 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 (i2 < 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 h2 = handler;
+      set.add(h2);
+      return () => {
+        set?.delete(h2);
+      };
+    },
+    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);
+    }
+  };
+}
+
+// src/client/errors.ts
+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 resetTurnstileForTests() {
+  loaderPromise = null;
+}
+function loadTurnstile() {
+  loaderPromise ?? (loaderPromise = new Promise((resolve, reject) => {
+    const present = installedApi();
+    if (present) {
+      resolve(present);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = TURNSTILE_SCRIPT_SRC;
+    script.async = true;
+    script.onload = () => {
+      const api = installedApi();
+      if (api) {
+        resolve(api);
+      } else {
+        loaderPromise = null;
+        reject(new Error("Turnstile script loaded but exposed no API"));
+      }
+    };
+    script.onerror = () => {
+      loaderPromise = null;
+      script.remove();
+      reject(new Error("Turnstile script failed to load"));
+    };
+    document.head.appendChild(script);
+  }));
+  return loaderPromise;
+}
+function abortError() {
+  return new Error("Turnstile challenge aborted");
+}
+async function executeTurnstile(siteKey, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? TURNSTILE_EXECUTE_TIMEOUT_MS;
+  const signal = opts.signal;
+  if (signal?.aborted) throw abortError();
+  const api = await loadTurnstile();
+  if (signal?.aborted) throw abortError();
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  let widgetId;
+  let timer;
+  let onAbort;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Turnstile challenge timed out (${timeoutMs} ms)`)),
+        timeoutMs
+      );
+      if (signal !== void 0) {
+        onAbort = () => reject(abortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      widgetId = api.render(container, {
+        sitekey: siteKey,
+        execution: "execute",
+        appearance: "execute",
+        callback: resolve,
+        "error-callback": (code) => {
+          reject(new Error(`Turnstile challenge failed${code ? ` (${code})` : ""}`));
+        }
+      });
+      if (widgetId === void 0) {
+        reject(new Error("Turnstile render returned no widget id"));
+        return;
+      }
+      api.execute(widgetId);
+    });
+  } finally {
+    clearTimeout(timer);
+    if (signal !== void 0 && onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+    if (widgetId !== void 0) {
+      try {
+        api.remove(widgetId);
+      } catch {
+      }
+    }
+    container.remove();
+  }
+}
+
+// src/verification/create-verification.ts
+var DEFAULT_API_ORIGIN = "https://api.sekyro.ai";
+var REGISTRY_RETRY_DELAY_MS = 5e3;
+var PROCESSING_POLL_DELAY_MS = 1500;
+var PROCESSING_POLL_MAX = 10;
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function randomUuid() {
+  const c2 = globalThis.crypto;
+  if (c2 !== void 0 && typeof c2.randomUUID === "function") return c2.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (c2 !== void 0 && typeof c2.getRandomValues === "function") c2.getRandomValues(bytes);
+  else for (let i2 = 0; i2 < 16; i2 += 1) bytes[i2] = 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 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,
+    (c2, idempotencyKey) => (
+      // `{}` input: the session is bound to a SERVER-provided NNI (Plan A Task 2).
+      c2.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 i2 = 0; i2 < PROCESSING_POLL_MAX && !destroyed && !isTerminalView(current) && frontierStep(current) === void 0 && current.steps.some((step) => step.state === "processing"); i2 += 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();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASPECT_BANDS,
+  AttestationError,
+  CAPTURE_CANDIDATE_SPACING_MS,
+  CAPTURE_EXTRA_CANDIDATES,
+  CENTERED_FACTOR,
+  CIRCLE_RADIUS_FACTOR,
+  CLIP_MIME_ALLOWLIST,
+  CaptureSessionDoc,
+  DOC_ANALYSIS_DEFAULTS,
+  DOC_CADENCE_HZ,
+  DOC_DETECT_WIDTH,
+  DOC_FEEDBACK_STATES,
+  DOC_GATE_V1_DEFAULTS,
+  DocFeedbackAggregator,
+  DocGateV1,
+  IN_CIRCLE_FACTOR,
+  MRZ_BAND_DEFAULTS,
+  MR_DOC_CATALOG,
+  PROCESSING_POLL_DELAY_MS,
+  PROCESSING_POLL_MAX,
+  REGISTRY_RETRY_DELAY_MS,
+  RETRYABLE_REASONS,
+  TRANSPORT_REPLAY_ATTEMPTS,
+  TRANSPORT_REPLAY_DELAY_MS,
+  TURNSTILE_EXECUTE_TIMEOUT_MS,
+  TURNSTILE_SCRIPT_SRC,
+  analyzeDocFrame,
+  aspectBand,
+  createLivenessCaptureInternal,
+  createVerificationInternal,
+  detectMrzBand,
+  executeTurnstile,
+  feedbackVoteOf,
+  frontierStep,
+  isExecutable,
+  isTerminalView,
+  loadTurnstile,
+  mapEngineState,
+  mapErrorKind,
+  mapGuidanceHint,
+  mapSessionResult,
+  mergeSessionView,
+  quadAreaFrac,
+  quadBounds,
+  quadIou,
+  quadTiltRatio,
+  randomUuid,
+  resetTurnstileForTests,
+  runLivenessFlow,
+  runSubmission,
+  specularFraction,
+  stepOf,
+  warmDocDetector
+});
+//# sourceMappingURL=index.cjs.map