@sekyro/web 0.1.0-rc.1 → 0.1.0-rc.2

package/dist/index.cjs

@@ -2064,6 +2064,7 @@ 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",
@@ -2124,6 +2125,7 @@ async function runSubmission(rt, executor, hooks = {}) {
     }
   }
 }
+var LIVENESS_CHAINABLE = /* @__PURE__ */ new Set(["passed", "review", "processing", "skipped"]);
 async function runLivenessFlow(deps) {
   const { artifacts } = deps;
   const clip = artifacts.clip;
@@ -2131,67 +2133,87 @@ async function runLivenessFlow(deps) {
   if (artifacts.degraded === "NO_RECORDER" || clip === void 0 || !CLIP_MIME_ALLOWLIST.includes(bareMime)) {
     return { kind: "unavailable", reason: "no_recorder" };
   }
-  try {
-    const livenessWasExecutable = isExecutable(stepOf(deps.getView(), "liveness"));
-    if (livenessWasExecutable) {
-      let clipKey = null;
-      let attestation = null;
-      const response = await 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: artifacts.captureChannel },
-            { idempotencyKey }
-          );
-        },
-        {
-          onAttestationInvalid: () => {
-            attestation = null;
-          }
-        }
-      );
-      if (deps.isCancelled()) return { kind: "cancelled" };
-      deps.applySubmit(response, "liveness");
-    }
+  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();
-    const liveness = stepOf(view, "liveness");
-    const livenessOk = !livenessWasExecutable || liveness === void 0 || liveness.state === "passed" || liveness.state === "review" || liveness.state === "processing" || liveness.state === "skipped";
-    if (!isTerminalView(view) && livenessOk && isExecutable(stepOf(view, "face_match"))) {
-      const keyframe = artifacts.keyframe;
-      let imageKey = null;
-      const response = await 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 });
-      });
+    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" };
-      deps.applySubmit(response, "face_match");
+      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;
+      }
     }
-    return { kind: "settled" };
-  } catch (err) {
-    if (deps.isCancelled()) return { kind: "cancelled" };
-    return classifyFailure(err);
-  }
+  );
+}
+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" };
@@ -2427,7 +2449,8 @@ function createVerificationInternal(options, internals) {
     };
   };
   let active = null;
-  let flowToken = 0;
+  let chain = Promise.resolve();
+  let chainDepth = 0;
   const settleProcessing = async () => {
     let current = await ensureView();
     for (let i = 0; i < PROCESSING_POLL_MAX && !destroyed && !isTerminalView(current) && frontierStep(current) === void 0 && current.steps.some((step) => step.state === "processing"); i += 1) {
@@ -2437,11 +2460,17 @@ function createVerificationInternal(options, internals) {
     }
     return current;
   };
-  const runFlow = async (capture, artifacts, token) => {
-    const isCancelled = () => destroyed || token !== flowToken || active !== capture;
+  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;
@@ -2453,7 +2482,7 @@ function createVerificationInternal(options, internals) {
       finish(unavailable(sessionId, "no_recorder"));
       return;
     }
-    capture.setFlowState("uploading");
+    setPhase("uploading");
     try {
       await startRegistry();
       if (isCancelled()) return;
@@ -2475,10 +2504,9 @@ function createVerificationInternal(options, internals) {
           artifacts,
           getAttestation,
           getView: () => view ?? current,
+          refreshView,
           applySubmit,
-          onPhase: (phase) => {
-            if (!isCancelled()) capture.setFlowState(phase);
-          },
+          onPhase: setPhase,
           isCancelled
         });
         if (isCancelled()) return;
@@ -2495,18 +2523,43 @@ function createVerificationInternal(options, internals) {
       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?.handle.destroy();
+    active?.capture.handle.destroy();
+    if (active !== null) active.alive = false;
     const capture = createLivenessCaptureInternal(captureOptions, internals.capture);
-    active = capture;
+    const bound = { capture, alive: true, attempt: 0 };
+    active = bound;
     capture.handle.on("state", (state) => {
-      if (state === "starting") flowToken += 1;
+      if (state === "starting") bound.attempt += 1;
     });
     capture.handle.on("captured", (artifacts) => {
-      const token = ++flowToken;
-      void Promise.resolve().then(() => runFlow(capture, artifacts, token));
+      void Promise.resolve().then(() => enqueueFlow(bound, artifacts));
     });
-    return capture.handle;
+    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(),
@@ -2516,8 +2569,11 @@ function createVerificationInternal(options, internals) {
     destroy: () => {
       destroyed = true;
       lifetime.abort();
-      active?.handle.destroy();
-      active = null;
+      if (active !== null) {
+        active.alive = false;
+        active.capture.handle.destroy();
+        active = null;
+      }
       emitter.clear();
     }
   };