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

package/dist/internal/index.js

@@ -0,0 +1,647 @@
+import {
+  AttestationError,
+  CLIP_MIME_ALLOWLIST,
+  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,
+  createLivenessCaptureInternal,
+  createVerificationInternal,
+  executeTurnstile,
+  frontierStep,
+  isExecutable,
+  isTerminalView,
+  loadTurnstile,
+  mapEngineState,
+  mapErrorKind,
+  mapGuidanceHint,
+  mapSessionResult,
+  mergeSessionView,
+  randomUuid,
+  resetTurnstileForTests,
+  runLivenessFlow,
+  runSubmission,
+  stepOf
+} from "../chunk-BPYVZUJA.js";
+import {
+  CENTERED_FACTOR,
+  CIRCLE_RADIUS_FACTOR,
+  IN_CIRCLE_FACTOR,
+  classifyDevice,
+  mapGetUserMediaError,
+  probeDevice
+} from "../chunk-LOTAJDRE.js";
+import "../chunk-YVFF4Q4G.js";
+import "../chunk-NWF46H7K.js";
+import {
+  ASPECT_BANDS,
+  DOC_DETECT_WIDTH,
+  DOC_GATE_V1_DEFAULTS,
+  DocGateV1,
+  MR_DOC_CATALOG,
+  aspectBand,
+  quadAreaFrac,
+  quadBounds,
+  quadIou
+} from "../chunk-WY6U7AIK.js";
+import {
+  EXPOSURE_BAND,
+  exposure,
+  meanLuma,
+  sharpness
+} from "../chunk-MWNFSNMP.js";
+
+// 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 t = { ...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 y = 0; y < height; y++) {
+    let edges = 0;
+    buckets.fill(false);
+    const rowOffset = y * 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 i = rowOffset + x * 4;
+      const luma = 0.299 * (data[i] ?? 0) + 0.587 * (data[i + 1] ?? 0) + 0.114 * (data[i + 2] ?? 0);
+      if (Math.abs(luma - previousLuma) >= t.EDGE_LUMA_DELTA) {
+        edges += 1;
+        buckets[Math.min(COLUMN_BUCKETS - 1, Math.floor(x / bucketWidth))] = true;
+        if (x < minX[y]) minX[y] = x;
+        if (x > maxX[y]) maxX[y] = x;
+      }
+      previousLuma = luma;
+    }
+    density[y] = edges / width;
+    const coverage = buckets.filter(Boolean).length / COLUMN_BUCKETS;
+    qualifies[y] = density[y] >= t.MIN_ROW_DENSITY && coverage >= t.MIN_COLUMN_COVERAGE && maxX[y] - minX[y] >= t.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 >= t.MIN_HEIGHT_FRAC * height && bandHeight <= t.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 y = 0; y < height; y++) {
+    if (qualifies[y]) {
+      if (runTop < 0) runTop = y;
+      else if (y - lastQualifying > t.ROW_MERGE_GAP) {
+        flush(lastQualifying);
+        runTop = y;
+      }
+      lastQualifying = y;
+      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 y = band.top; y <= band.bottom; y++) {
+    if (!qualifies[y]) continue;
+    if (minX[y] < x1) x1 = minX[y];
+    if (maxX[y] > x2) x2 = maxX[y];
+    densitySum += density[y];
+    densityRows += 1;
+  }
+  if (x2 - x1 < t.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
+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 i = 0; i < pixels; i++) {
+    const o = i * 4;
+    const luma = 0.299 * (data[o] ?? 0) + 0.587 * (data[o + 1] ?? 0) + 0.114 * (data[o + 2] ?? 0);
+    if (luma >= 252) hot++;
+  }
+  return hot / pixels;
+}
+function quadTiltRatio(quad) {
+  const len = (a, b) => Math.hypot(b.x - a.x, b.y - a.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 h = 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(h, v);
+}
+function analyzeDocFrame(input) {
+  const t = { ...DOC_GATE_V1_DEFAULTS, ...input.thresholds };
+  const a = 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 < t.ID3_BAND_MIN_WIDTH_FRAC) framing = "too_far";
+    else if (edgeClipped(quad, frameWidth, frameHeight, t.EDGE_CLIP_MARGIN_PX)) {
+      framing = "edge_clipped";
+    } else if (aspect < t.ID3_BAND_ASPECT_MIN || aspect > t.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 < t.MIN_AREA_FRAC) framing = "too_far";
+    else if (areaFrac > a.MAX_AREA_FRAC) framing = "too_close";
+    else if (edgeClipped(quad, frameWidth, frameHeight, t.EDGE_CLIP_MARGIN_PX)) {
+      framing = "edge_clipped";
+    } else if (Math.abs(aspect - band.center) > band.tolerance) framing = "wrong_shape";
+    else if (quadTiltRatio(quad) > a.TILT_MAX_SIDE_RATIO) framing = "tilted";
+  }
+  const lighting = measures.exposure >= t.GUIDE_EXPOSURE ? "ok" : measures.meanLuma < (EXPOSURE_BAND[0] + EXPOSURE_BAND[1]) / 2 ? "too_dark" : "too_bright";
+  const blur = measures.sharpness >= t.GUIDE_SHARPNESS ? "ok" : "blurry";
+  const glare = measures.specularFraction >= a.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(
+    (p) => p.x <= margin || p.y <= margin || p.x >= frameWidth - margin || p.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/doc/capture-session-doc.ts
+var scanicDetect = null;
+async function lazyScanicDetect(image) {
+  if (scanicDetect === null) {
+    const module_ = await import("../detector-scanic-4C6IEW2K.js");
+    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 import("../detector-scanic-4C6IEW2K.js").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 i = 0; i < CAPTURE_EXTRA_CANDIDATES; i++) {
+        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 };
+}
+export {
+  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.js.map