@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/PrivacyLensProvider-D8PS7AJa.esm.js

@@ -0,0 +1,405 @@
+import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
+import { a as publishAvatarStats, r as isAvatarStatsEnabled, t as createAvatarStatsReporter } from "./avatarStats-CdUOb3VD.esm.js";
+import { a as createPrivacyLensGl, i as detectWorkerSourceInstrumentation, n as canUsePrivacyLensWorker, o as createFramePacer, r as createTrackProcessor, t as buildPrivacyLensWorkerSource } from "./privacyLensWorker-DI-Rg83h.esm.js";
+//#region ../infra/src/avatar/privacy-lens/privacyLensShaders.ts
+/** Starting point; tuned live via the privacy-lens demo sliders. */
+const PRIVACY_LENS_DEFAULTS = {
+	frost: .55,
+	sandblast: .28,
+	grainSize: .5,
+	brightness: 1.12,
+	shadowLift: .12,
+	warmth: .5,
+	sun: .71,
+	sunSpeed: .26
+};
+const PRIVACY_LENS_VERT = `
+attribute vec2 aPos;
+varying vec2 vUv;
+void main() {
+  vUv = aPos * 0.5 + 0.5;
+  gl_Position = vec4(aPos, 0.0, 1.0);
+}`;
+const GOLDEN_ANGLE = 2.399963;
+/** GLSL float literal (toFixed always keeps the `.` GLSL ES 1.00 requires). */
+const f = (x) => x.toFixed(7);
+const PRIVACY_LENS_FRAG = `
+// The grain hash (h21 below) feeds large gl_FragCoord-derived values through
+// sin()*43758.5 — that overflows mediump's range on many mobile GPUs and
+// collapses the grain to a flat artifact. Use highp where available (all WebGL2
+// and most WebGL1 devices); fall back to mediump on the rare device without it.
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+varying vec2 vUv;
+uniform sampler2D uVideo;
+uniform vec2 uRes;        // canvas pixel size (square)
+uniform vec2 uVideoRes;   // decoded video pixel size
+uniform float uTime;      // seconds (sun drift only)
+uniform float uFrost;
+uniform float uSandblast;
+uniform float uGrainSize;
+uniform float uWarmth;
+uniform float uBright;
+uniform float uShadow;
+uniform float uSun;
+uniform float uSunSpeed;
+
+// Static per-cell hash — NO time term, so the grain is a fixed matte surface.
+float h21(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+// Cover-fit the (non-square) video into the square output, centre-cropped, so
+// faces are never stretched. Also flips V: the texture is uploaded without
+// UNPACK_FLIP_Y_WEBGL (see PrivacyLensProvider), so row 0 is the TOP of the
+// frame; the flip is symmetric around 0.5, so it composes with the cover crop.
+vec2 coverUv(vec2 uv) {
+  float va = uVideoRes.x / max(uVideoRes.y, 1.0);
+  vec2 o = uv;
+  if (va > 1.0) o.x = (uv.x - 0.5) / va + 0.5;   // landscape: crop sides
+  else          o.y = (uv.y - 0.5) * va + 0.5;    // portrait: crop top/bottom
+  return vec2(o.x, 1.0 - o.y);
+}
+
+void main() {
+  vec2 uv = vUv;
+  vec2 base = coverUv(uv);
+  float aspect = uRes.y / max(uRes.x, 1.0);
+
+  // Per-fragment static seed, clustered into grain cells. Small cells = ultra
+  // fine sandblast (effectively invisible pattern); larger = coarser frosting.
+  vec2 cell = floor(gl_FragCoord.xy / max(uGrainSize, 0.5));
+  float rnd = h21(cell);
+  float baseAngle = rnd * 6.2831853;
+
+  // Stochastic sandblasted scatter: an even golden-angle disk, but each pixel
+  // cell rotates + jitters the kernel differently → a fine matte grain rather
+  // than a smooth blur. The video moves UNDER this fixed glass grain. Taps are
+  // unrolled with baked constants; the per-cell rotation is the single
+  // cos/sin pair below (see TAPS_GLSL).
+  float cb = cos(baseAngle);
+  float sb = sin(baseAngle);
+  float j; float r; vec2 off;
+  vec3 col = vec3(0.0);
+${Array.from({ length: 12 }, (_, i) => {
+	const fi = i + .5;
+	const ux = Math.cos(fi * GOLDEN_ANGLE);
+	const uy = Math.sin(fi * GOLDEN_ANGLE);
+	const rad = Math.sqrt(fi / 12);
+	return `  j = h21(cell + vec2(${f(fi * 7.13)}, ${f(fi * 3.71)}));
+  r = uFrost * 0.06 * ${f(rad)} + (j - 0.5) * uSandblast * 0.03;
+  off = vec2(cb * ${f(ux)} - sb * ${f(uy)}, sb * ${f(ux)} + cb * ${f(uy)}) * r;
+  off.x *= aspect;
+  col += texture2D(uVideo, base + off).rgb;`;
+}).join("\n")}
+  col /= ${f(12)};
+
+  // Airy + warm grade (luminous frosted glass, not murky).
+  col = col + uShadow * (1.0 - col);
+  col *= uBright;
+  vec3 warm = vec3(1.0, 0.92, 0.80);
+  col = mix(col, col * warm + vec3(0.03, 0.015, 0.0), uWarmth);
+
+  // Drifting sun: a broad soft glow + a fine STATIC sparkle (per-cell) that
+  // catches the ground-glass grain only where the light falls — not all-over.
+  vec2 sun = vec2(0.34 + 0.16 * sin(uTime * uSunSpeed),
+                  0.26 + 0.10 * cos(uTime * uSunSpeed * 0.8));
+  float glow = smoothstep(0.7, 0.0, distance(uv, sun));
+  vec3 sunCol = vec3(1.0, 0.96, 0.88);
+  col += sunCol * glow * (0.20 + (rnd - 0.5) * 0.18 * uSandblast) * uSun;
+
+  gl_FragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
+}`;
+//#endregion
+//#region ../infra/src/avatar/privacy-lens/PrivacyLensProvider.ts
+/**
+* Privacy-lens avatar — sandblasted-glass effect over the **real** selfie video.
+* **Self-contained** (see FACE_AVATAR.md → Isolation and ownership). No MediaPipe, no landmarks, no
+* three/VRM, no npm deps, no textures but the live video — just a raw-WebGL
+* fragment shader run on the video each frame (see `privacyLensShaders.ts`,
+* `privacyLensGlCore.ts`).
+*
+* Two render transports (ENG-49806):
+*  - **Worker mode (preferred, Chromium 94+):** camera track (cloned) →
+*    `MediaStreamTrackProcessor` → VideoFrame stream → worker → OffscreenCanvas.
+*    The main thread is NOT in the frame path, so the lens stays smooth even
+*    when the synchronous WASM detection pipeline saturates the main thread
+*    (measured: main-thread lens starves to ~1.6-3fps under low-tier CPU
+*    throttle with 0ms upload/draw — scheduling, not work, is the bottleneck).
+*  - **Main-thread mode (fallback):** hidden decode `<video>` + rVFC/rAF loop,
+*    for Safari/Firefox/old WebView and strict-CSP hosts that block blob
+*    workers.
+*
+* Implements `IFaceAvatarCapability` (the generic `start/getCanvas/stop`
+* contract) so it rides the existing concealment seam
+* (`selfieConcealmentOption: 'OPTION_SILHOUETTE'`). Cosmetic-only: the
+* authoritative pipeline still runs on the real frames; the worker consumes a
+* CLONED track so lens lifecycle can never affect capture. Mirroring is the
+* UI's job (CSS), like every other provider — the shader renders forward.
+*/
+const DEFAULT_MAX_FPS = 30;
+const RENDER_SIZE = 512;
+/** Worker must boot + init GL within this budget, else fall back. */
+const WORKER_START_TIMEOUT_MS = 5e3;
+/** Cadence of the main→worker dev-params/stats-flag bridge. */
+const PARAM_BRIDGE_INTERVAL_MS = 250;
+/** Grace period for the worker to ack 'stop' before hard termination. */
+const WORKER_STOP_GRACE_MS = 500;
+const asRvfc = (video) => {
+	const v = video;
+	return typeof v.requestVideoFrameCallback === "function" && typeof v.cancelVideoFrameCallback === "function" ? v : null;
+};
+const readParams = () => {
+	if (typeof window === "undefined") return PRIVACY_LENS_DEFAULTS;
+	const override = window.__incodePrivacyLensParams;
+	return override ? {
+		...PRIVACY_LENS_DEFAULTS,
+		...override
+	} : PRIVACY_LENS_DEFAULTS;
+};
+var PrivacyLensProvider = class PrivacyLensProvider {
+	constructor() {
+		this.glCore = null;
+		this.videoHandle = null;
+		this.rafId = null;
+		this.rvfcHandle = null;
+		this.usingRvfc = false;
+		this.stopped = false;
+		this.pacer = createFramePacer(DEFAULT_MAX_FPS);
+		this.stats = createAvatarStatsReporter("privacy-lens", "main");
+		this.startTime = 0;
+		this.lastVideoTime = -1;
+		this.worker = null;
+		this.clonedTrack = null;
+		this.paramBridgeId = null;
+		this.lastBridgedParams = "";
+		this.lastBridgedStatsEnabled = false;
+		this.loop = (now) => {
+			if (this.stopped) return;
+			this.scheduleNextFrame();
+			const glCore = this.glCore;
+			const video = this.videoHandle?.element;
+			if (!glCore) return;
+			if (!video || video.readyState < 2 || !video.videoWidth) {
+				glCore.clear();
+				return;
+			}
+			if (!this.usingRvfc) {
+				if (video.currentTime === this.lastVideoTime) return;
+				this.lastVideoTime = video.currentTime;
+			}
+			if (!this.pacer.shouldRender(now)) {
+				this.stats.frameDropped();
+				return;
+			}
+			const measure = isAvatarStatsEnabled();
+			const timing = glCore.render(video, video.videoWidth, video.videoHeight, (now - this.startTime) / 1e3, readParams(), measure);
+			if (measure) this.stats.frameRendered(now, timing?.uploadMs, timing?.drawMs);
+		};
+		this.canvas = PrivacyLensProvider.createCanvas();
+	}
+	static createCanvas() {
+		const canvas = document.createElement("canvas");
+		canvas.width = RENDER_SIZE;
+		canvas.height = RENDER_SIZE;
+		return canvas;
+	}
+	getCanvas() {
+		return this.canvas;
+	}
+	async start(stream, options = {}) {
+		const maxFps = options.maxFps ?? DEFAULT_MAX_FPS;
+		this.pacer = createFramePacer(maxFps);
+		if (await this.tryStartWorker(stream, maxFps)) return;
+		if (this.stopped) return;
+		this.startMainThread(stream);
+	}
+	/**
+	* Worker transport: clone the track, feed it to a MediaStreamTrackProcessor,
+	* boot a blob worker, transfer the readable + the canvas, and wait for the
+	* 'started' handshake. Any failure (unsupported browser, CSP-blocked blob
+	* worker, GL init failure in the worker) tears down and returns false so the
+	* main-thread path takes over. Never throws.
+	*/
+	async tryStartWorker(stream, maxFps) {
+		if (!canUsePrivacyLensWorker()) return false;
+		const sourceTrack = stream.getVideoTracks()[0];
+		if (!sourceTrack) return false;
+		let track = null;
+		let processor;
+		try {
+			track = sourceTrack.clone();
+			processor = createTrackProcessor(track);
+		} catch {
+			track?.stop();
+			return false;
+		}
+		const source = buildPrivacyLensWorkerSource({
+			vertSrc: PRIVACY_LENS_VERT,
+			fragSrc: PRIVACY_LENS_FRAG,
+			renderSize: RENDER_SIZE
+		});
+		const instrumenter = detectWorkerSourceInstrumentation(source);
+		if (instrumenter) {
+			console.error(`[privacy-lens] render worker source was instrumented by "${instrumenter}" and cannot run in a worker; using the slower main-thread lens. Exclude packages/infra from that transform (see docs/features/FACE_AVATAR.md → Worker transport).`);
+			track.stop();
+			return false;
+		}
+		let worker = null;
+		let blobUrl = null;
+		try {
+			blobUrl = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+			worker = new Worker(blobUrl);
+		} catch {
+			if (blobUrl) URL.revokeObjectURL(blobUrl);
+			track.stop();
+			return false;
+		}
+		let started;
+		try {
+			const offscreen = this.canvas.transferControlToOffscreen();
+			const startedWorker = worker;
+			started = await new Promise((resolve) => {
+				const timer = setTimeout(() => resolve(false), WORKER_START_TIMEOUT_MS);
+				startedWorker.onmessage = (event) => {
+					if (event.data?.type === "started") {
+						clearTimeout(timer);
+						resolve(true);
+					} else if (event.data?.type === "fatal") {
+						clearTimeout(timer);
+						resolve(false);
+					}
+				};
+				startedWorker.onerror = () => {
+					clearTimeout(timer);
+					resolve(false);
+				};
+				startedWorker.postMessage({
+					type: "start",
+					canvas: offscreen,
+					readable: processor.readable,
+					maxFps,
+					params: readParams(),
+					statsEnabled: isAvatarStatsEnabled()
+				}, [offscreen, processor.readable]);
+			});
+		} catch {
+			worker.terminate();
+			URL.revokeObjectURL(blobUrl);
+			track.stop();
+			if (!this.stopped) this.canvas = PrivacyLensProvider.createCanvas();
+			return false;
+		}
+		URL.revokeObjectURL(blobUrl);
+		if (!started || this.stopped) {
+			worker.terminate();
+			track.stop();
+			if (!this.stopped) this.canvas = PrivacyLensProvider.createCanvas();
+			return this.stopped;
+		}
+		this.worker = worker;
+		this.clonedTrack = track;
+		this.lastBridgedParams = JSON.stringify(readParams());
+		this.lastBridgedStatsEnabled = isAvatarStatsEnabled();
+		worker.onmessage = (event) => {
+			const message = event.data;
+			if (message?.type === "stats") {
+				if (!this.stopped) publishAvatarStats(message.snapshot);
+			} else if (message?.type === "stopped") this.finalizeWorker();
+		};
+		worker.onerror = () => {
+			console.warn("[privacy-lens] render worker error — lens frozen (capture unaffected)");
+			if (this.paramBridgeId != null) {
+				clearInterval(this.paramBridgeId);
+				this.paramBridgeId = null;
+			}
+			this.finalizeWorker();
+		};
+		this.paramBridgeId = setInterval(() => {
+			if (!this.worker) return;
+			const params = readParams();
+			const serialized = JSON.stringify(params);
+			if (serialized !== this.lastBridgedParams) {
+				this.lastBridgedParams = serialized;
+				this.worker.postMessage({
+					type: "params",
+					params
+				});
+			}
+			const statsEnabled = isAvatarStatsEnabled();
+			if (statsEnabled !== this.lastBridgedStatsEnabled) {
+				this.lastBridgedStatsEnabled = statsEnabled;
+				this.worker.postMessage({
+					type: "statsEnabled",
+					value: statsEnabled
+				});
+			}
+		}, PARAM_BRIDGE_INTERVAL_MS);
+		return true;
+	}
+	/** Main-thread transport: hidden decode video + rVFC/rAF render loop. */
+	startMainThread(stream) {
+		this.videoHandle = createHiddenVideoElement(stream, { keepStreamAlive: true });
+		try {
+			this.glCore = createPrivacyLensGl(this.canvas, PRIVACY_LENS_VERT, PRIVACY_LENS_FRAG, RENDER_SIZE);
+			if (this.stopped) return;
+			this.startTime = performance.now();
+			const video = this.videoHandle.element;
+			this.usingRvfc = !!asRvfc(video);
+			this.scheduleNextFrame();
+		} catch (error) {
+			this.stop();
+			throw error;
+		}
+	}
+	stop() {
+		this.stopped = true;
+		this.stats.dispose();
+		if (this.paramBridgeId != null) {
+			clearInterval(this.paramBridgeId);
+			this.paramBridgeId = null;
+		}
+		if (this.worker) {
+			this.worker.postMessage({ type: "stop" });
+			const pending = this.worker;
+			setTimeout(() => {
+				if (this.worker === pending) this.finalizeWorker();
+			}, WORKER_STOP_GRACE_MS);
+		}
+		if (this.rafId != null) {
+			cancelAnimationFrame(this.rafId);
+			this.rafId = null;
+		}
+		const video = this.videoHandle?.element;
+		if (video && this.rvfcHandle != null) {
+			asRvfc(video)?.cancelVideoFrameCallback(this.rvfcHandle);
+			this.rvfcHandle = null;
+		}
+		this.glCore?.dispose();
+		this.glCore = null;
+		this.videoHandle?.dispose();
+		this.videoHandle = null;
+	}
+	finalizeWorker() {
+		this.worker?.terminate();
+		this.worker = null;
+		this.clonedTrack?.stop();
+		this.clonedTrack = null;
+	}
+	scheduleNextFrame() {
+		if (this.stopped) return;
+		const video = this.videoHandle?.element;
+		const rvfc = this.usingRvfc && video ? asRvfc(video) : null;
+		if (rvfc) this.rvfcHandle = rvfc.requestVideoFrameCallback(this.loop);
+		else this.rafId = requestAnimationFrame(this.loop);
+	}
+};
+/** Factory used by the avatar actor's provider selection (privacy-lens avatar). */
+function createProvider() {
+	return new PrivacyLensProvider();
+}
+//#endregion
+export { PrivacyLensProvider, createProvider };

package/dist/StateMachine-EDpYWy0i.d.ts

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/declarations/src/index.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}

package/dist/{StreamCanvasCapture-CAqUdVkM.esm.js → StreamCanvasCapture-D2XcXCZ4.esm.js}

@@ -1,5 +1,4 @@
-import { t as IncodeCanvas } from "./canvas-Pi10hG_l.esm.js";
-
+import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 //#region ../infra/src/media/StreamCanvasCapture.ts
 var StreamCanvasCapture = class {
 	constructor(stream, options) {
@@ -113,6 +112,5 @@ var StreamCanvasCapture = class {
 		}
 	}
 };
-
 //#endregion
-export { StreamCanvasCapture as t };
+export { StreamCanvasCapture as t };

package/dist/{addressSearch-D7msRieq.esm.js → addressSearch-DQyrvDQj.esm.js}

@@ -1,10 +1,8 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { i as fromCallback } from "./xstate.esm-nY3M5UYm.esm.js";
-
-//#region src/shared/usStates.ts
-const usStates = {
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+const usStateOptions = Object.values({
 	AL: {
 		code: "AL",
 		name: "Alabama"
@@ -205,12 +203,10 @@ const usStates = {
 		code: "WY",
 		name: "Wyoming"
 	}
-};
-const usStateOptions = Object.values(usStates).map((state) => ({
+}).map((state) => ({
 	value: state.code,
 	label: state.name
 }));
-
 //#endregion
 //#region src/shared/addressSuggestion.ts
 /** Shown when an autocomplete suggestion has no street (city/region-level result). */
@@ -266,14 +262,9 @@ function buildStreetValue(street, houseNumber, hasHouseNoField) {
 	if (houseNumber && street) return `${houseNumber} ${street}`;
 	return houseNumber ?? street ?? "";
 }
-
 //#endregion
 //#region src/shared/displayErrors.ts
 const DYNAMIC_REQUIRED_KEY = "verification.errors.fieldRequiredDynamic";
-
-//#endregion
-//#region src/shared/postalCode.ts
-const DEFAULT_POSTAL_CODE_MAX_LENGTH = 8;
 const POSTAL_CODE_MAX_LENGTH_BY_COUNTRY = {
 	US: 10,
 	BR: 9,
@@ -304,7 +295,7 @@ const FIXED_DIGIT_POSTAL_CODE_LENGTH = {
 	IL: 7
 };
 function getPostalCodeMaxLength(country) {
-	return POSTAL_CODE_MAX_LENGTH_BY_COUNTRY[country] ?? DEFAULT_POSTAL_CODE_MAX_LENGTH;
+	return POSTAL_CODE_MAX_LENGTH_BY_COUNTRY[country] ?? 8;
 }
 function getPostalCodeErrorKey(country) {
 	if (country in FIXED_DIGIT_POSTAL_CODE_LENGTH) return FIXED_LENGTH_KEY;
@@ -347,7 +338,7 @@ function validatePostalCode(postalCode, country) {
 		case "CM": return postalCode.length > 0;
 		default: {
 			const stripped = postalCode.replace(/\D/g, "");
-			return /^\d+$/.test(stripped) && [5, DEFAULT_POSTAL_CODE_MAX_LENGTH].includes(stripped.length);
+			return /^\d+$/.test(stripped) && [5, 8].includes(stripped.length);
 		}
 	}
 }
@@ -382,9 +373,8 @@ function formatPostalCode(value, country) {
 	if (country === "IL") return value.replace(/\D/g, "").slice(0, 7);
 	if (country === "CN" || country === "NG") return value.replace(/\D/g, "").slice(0, 6);
 	if (country === "DE" || country === "FR" || country === "IT" || country === "MX" || country === "KE") return value.replace(/\D/g, "").slice(0, 5);
-	return value.slice(0, DEFAULT_POSTAL_CODE_MAX_LENGTH);
+	return value.slice(0, 8);
 }
-
 //#endregion
 //#region src/shared/addressSearch.ts
 /** Searches for address suggestions via the address autocomplete API. */
@@ -431,6 +421,5 @@ const debounceSearchActor = fromCallback(({ input, sendBack }) => {
 		controller.abort();
 	};
 });
-
 //#endregion
-export { getPostalCodeMaxLength as a, STREET_LEVEL_REQUIRED_ERROR as c, usStateOptions as d, getPostalCodeErrorKey as i, fillFromSuggestion as l, FIXED_DIGIT_POSTAL_CODE_LENGTH as n, validatePostalCode as o, formatPostalCode as r, DYNAMIC_REQUIRED_KEY as s, debounceSearchActor as t, getStreetLevelErrorForSuggestion as u };
+export { getPostalCodeMaxLength as a, STREET_LEVEL_REQUIRED_ERROR as c, usStateOptions as d, getPostalCodeErrorKey as i, fillFromSuggestion as l, FIXED_DIGIT_POSTAL_CODE_LENGTH as n, validatePostalCode as o, formatPostalCode as r, DYNAMIC_REQUIRED_KEY as s, debounceSearchActor as t, getStreetLevelErrorForSuggestion as u };

package/dist/ae-signature.d.ts

@@ -1,10 +1,8 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { a as AE_CONSENT_KEYS, c as ConsentKey, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-36QX_21w.js";
-
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import { _ as getDefaultConsentChecks, a as ElectronicSignatureConfig, h as areAllConsented, i as ConsentKey, r as ConsentChecks, s as ElectronicSignatureDocument, t as AE_CONSENT_KEYS } from "./types-DVmXIdzW.js";
+import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-CcUXQZS7.js";
+import "./electronic-signature.js";
 //#region src/modules/ae-signature/index.d.ts
-
 type AeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
 declare function createAeSignatureManager(options: {
   config: AeSignatureConfig;

package/dist/ae-signature.esm.js

@@ -1,11 +1,10 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import "./urlUtils-CpiYwn7w.esm.js";
-import "./externalFetch-hvmz_npP.esm.js";
-import "./apiError-DkOXfFBu.esm.js";
-import { a as areAllConsented, n as electronicSignatureMachine, r as AE_CONSENT_KEYS, s as getDefaultConsentChecks } from "./electronicSignatureManager-DESRgObX.esm.js";
-import { t as createAeSignatureManager } from "./ae-signature-Pp4oCAHD.esm.js";
-
-export { AE_CONSENT_KEYS, electronicSignatureMachine as aeSignatureMachine, areAllConsented, createAeSignatureManager, getDefaultConsentChecks };
+import { c as getDefaultConsentChecks, i as AE_CONSENT_KEYS, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-DRYlHPjT.esm.js";
+//#region src/modules/ae-signature/index.ts
+function createAeSignatureManager(options) {
+	return createElectronicSignatureManager({ config: {
+		...options.config,
+		variant: "ae"
+	} });
+}
+//#endregion
+export { AE_CONSENT_KEYS, electronicSignatureMachine as aeSignatureMachine, areAllConsented, createAeSignatureManager, getDefaultConsentChecks };

package/dist/antifraud.d.ts

@@ -1,10 +1,5 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { i as createAntifraudManagerFromActor, n as AntifraudState, o as antifraudMachine, r as createAntifraudManager, t as AntifraudManager } from "./antifraudManager-DCiNI6np.js";
-
+import { i as createAntifraudManagerFromActor, n as AntifraudState, o as antifraudMachine, r as createAntifraudManager, t as AntifraudManager } from "./antifraudManager-BY36bS12.js";
 //#region src/modules/antifraud/types.d.ts
-
 /**
  * Configuration options for the antifraud module.
  *

package/dist/antifraud.esm.js

@@ -1,8 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-BQVw46N5.esm.js";
-import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-5KA84wtF.esm.js";
-
-export { antifraudMachine, createAntifraudManager, createAntifraudManagerFromActor };
+import { t as antifraudMachine } from "./antifraudStateMachine-r4VxSBS4.esm.js";
+import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-B8Plzf7a.esm.js";
+export { antifraudMachine, createAntifraudManager, createAntifraudManagerFromActor };

package/dist/{antifraudManager-5KA84wtF.esm.js → antifraudManager-B8Plzf7a.esm.js}

@@ -1,12 +1,11 @@
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-BQVw46N5.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-r4VxSBS4.esm.js";
 //#region src/modules/antifraud/antifraudActor.ts
 function createAntifraudActor() {
 	return createActor(antifraudMachine).start();
 }
-
 //#endregion
 //#region src/modules/antifraud/antifraudManager.ts
 /**
@@ -44,7 +43,12 @@ function mapState(snapshot) {
 	return { status: "idle" };
 }
 function createApi({ actor }) {
-	return { load() {
+	return { 
+	/**
+	* Kicks off the antifraud process.
+	* Transitions from 'idle' to 'processing'.
+	*/
+load() {
 		actor.send({ type: "LOAD" });
 	} };
 }
@@ -78,6 +82,5 @@ function createAntifraudManagerFromActor(actor) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.antifraud, { getEventScreenName: getAntifraudScreenName })
 	});
 }
-
 //#endregion
-export { createAntifraudManagerFromActor as n, createAntifraudManager as t };
+export { createAntifraudManagerFromActor as n, createAntifraudManager as t };

package/dist/{antifraudManager-DCiNI6np.d.ts → antifraudManager-BY36bS12.d.ts}

@@ -1,6 +1,6 @@
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
 //#region src/modules/antifraud/antifraudStateMachine.d.ts
 declare const antifraudMachine: any;
 type AntifraudMachine = typeof antifraudMachine;

package/dist/{antifraudStateMachine-BQVw46N5.esm.js → antifraudStateMachine-r4VxSBS4.esm.js}

@@ -1,14 +1,13 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/antifraud/antifraudServices.ts
 async function processAntifraud(signal) {
 	const res = await api.get(endpoints.processAntifraud, { signal });
 	if (!res.ok) throw new Error(`GET ${endpoints.processAntifraud} failed: ${res.status} ${res.statusText}`);
 	return res.data;
 }
-
 //#endregion
 //#region src/modules/antifraud/antifraudStateMachine.ts
 const antifraudMachine = setup({
@@ -34,6 +33,5 @@ const antifraudMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { antifraudMachine as t };
+export { antifraudMachine as t };