@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/{createFaceAvatar-DQKaRise.esm.js → createFaceAvatar-BNHdeFj8.esm.js}

@@ -3,8 +3,8 @@ import { i as markAvatarTimeline } from "./avatarStats-CdUOb3VD.esm.js";
 async function importProviderModule(variant) {
 	switch (variant) {
 		case "avatar-3d": return import("./3dAvatarProvider-g02DTFqT.esm.js");
-		case "avatar-2d": return import("./Face2DProvider-UUQt_vRC.esm.js");
-		case "privacy-lens": return import("./PrivacyLensProvider-D8PS7AJa.esm.js");
+		case "avatar-2d": return import("./Face2DProvider-BF48sz5c.esm.js");
+		case "privacy-lens": return import("./PrivacyLensProvider-EwnC_C5n.esm.js");
 		default: throw new Error(`Unknown avatar variant: ${String(variant)}`);
 	}
 }

package/dist/createFaceAvatar-BlcTYgJv.d.ts

@@ -0,0 +1,497 @@
+import { i as WasmModuleConfig, n as WasmModelsConfig } from "./warmup-Cis2p6O0.js";
+//#region ../infra/src/media/canvas.d.ts
+/**
+ * Class representing a canvas element for image capture and manipulation.
+ */
+declare class IncodeCanvas {
+  canvas: HTMLCanvasElement;
+  private base64Image;
+  private blobData;
+  /**
+   * Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+   * @param imageData - Frame pixels in RGBA format
+   * @returns An {@link IncodeCanvas} containing the provided pixels
+   */
+  static fromImageData(imageData: ImageData): IncodeCanvas;
+  /**
+   * Create a new canvas element.
+   * @param canvas_ - The canvas element to clone.
+   */
+  constructor(canvas_: HTMLCanvasElement);
+  /**
+   * Check if the current canvas is valid.
+   */
+  private checkCanvas;
+  /**
+   * Disposes of resources, including revoking object URLs to prevent memory leaks.
+   */
+  dispose(): void;
+  /**
+   * Release the data stored by IncodeCanvas.
+   */
+  release(): void;
+  /**
+   * Revokes the object URL if one exists, preventing memory leaks.
+   * Use this when you no longer need the preview image URL.
+   */
+  revokeObjectURL(): void;
+  /**
+   * Get the width of the canvas.
+   */
+  width(): number | null;
+  /**
+   * Get the height of the canvas.
+   */
+  height(): number | null;
+  /**
+   * Set the width of the canvas.
+   */
+  setWidth(width: number): void;
+  /**
+   * Set the height of the canvas.
+   */
+  setHeight(height: number): void;
+  /**
+   * Clone the current canvas.
+   */
+  clone(): IncodeCanvas | null;
+  /**
+   * Deep clone the current IncodeCanvas including blob data.
+   */
+  deepClone(): Promise<IncodeCanvas | null>;
+  /**
+   * Returns the drawing context on the canvas.
+   */
+  getContext(contextId: '2d', contextAttributes?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+  /**
+   * Retrieves the image data from the canvas.
+   */
+  getImageData(): ImageData | null;
+  /**
+   * Updates the base64 representation of the current canvas image.
+   */
+  updateBase64Image(jpegQuality?: number): void;
+  /**
+   * Converts the current canvas element to a base64 string.
+   */
+  getBase64Image(jpegQuality?: number, includeDataURLPrefix?: boolean): string | null;
+  /**
+   * Sets the base64 representation of the current canvas image.
+   */
+  setBase64Image(base64Image: string | null): void;
+  /**
+   * Updates the Blob representation of the current canvas image.
+   */
+  updateBlob(jpegQuality?: number, includeDataURLPrefix?: boolean): void;
+  /**
+   * Creates a JPEG Blob without synchronously encoding the canvas as base64.
+   * Returns `null` when the canvas is invalid, encoding is unavailable, or the
+   * browser cannot produce a Blob.
+   */
+  updateBlobAsync(jpegQuality?: number): Promise<{
+    blob: Blob;
+    url: string;
+  } | null>;
+  /**
+   * Converts a base64 string to a Blob and creates a URL for it.
+   */
+  static base64ToBlob(base64: string): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Retrieves the Blob data and its URL from the current canvas.
+   */
+  getBlobData(jpegQuality?: number, includeDataURLPrefix?: boolean): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Sets the Blob data of the current canvas image.
+   */
+  setBlobData(blobData: {
+    blob: Blob;
+    url: string;
+  }): Promise<void>;
+  /**
+   * Returns a resized canvas according to video element size.
+   */
+  getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
+}
+//#endregion
+//#region ../infra/src/wasm/wasmWebClient.d.ts
+/**
+ * Configuration shape that the C++ `WebApi` passes when calling `.post(...)`
+ * on its host JS adapter. Mirrors the upstream `ml-wasm-kit/WebClient`
+ * `RequestConfig` for the subset of fields actually set by `WebApi`.
+ */
+type WebApiHostRequestConfig = {
+  ie?: boolean;
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined>;
+  timeout?: number;
+};
+//#endregion
+//#region ../infra/src/capabilities/IMLProviderCapability.d.ts
+/** WASM module and model configuration shared by ML providers. */
+type MLProviderConfig = Partial<WasmModuleConfig> & WasmModelsConfig;
+/**
+ * Base interface for ML provider capabilities.
+ * Provides common lifecycle and frame processing methods shared by
+ * FaceDetectionCapability and IdCaptureCapability.
+ */
+interface IMLProviderCapability<TConfig extends MLProviderConfig> {
+  /**
+   * Whether the provider has been initialized and is ready to process frames.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `setup()` or `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: TConfig): Promise<void>;
+  /**
+   * Processes a frame through the ML pipeline.
+   * Callbacks set via `setCallbacks()` will be invoked based on the analysis results.
+   * @param image - Image data to process
+   * @throws Error if provider is not initialized
+   */
+  processFrame(image: ImageData): Promise<void>;
+  /**
+   * Resets the pipeline to its initial state.
+   * Safe to call even if not initialized (no-op in that case).
+   */
+  reset(): void;
+  /**
+   * Disposes of resources and resets initialization state.
+   * Safe to call even if not initialized.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/capabilities/IFaceDetectionCapability.d.ts
+/**
+ * Configuration for face detection provider.
+ * Extends base ML provider config with face-detection specific options.
+ */
+interface FaceDetectionConfig extends MLProviderConfig {
+  autocaptureInterval?: number;
+  /**
+   * Load the on-device selfie workflow (6 models including liveness + age
+   * estimation) instead of the default selfie workflow (4 models). Required
+   * when SELFIE/AUTHENTICATION has `onDeviceFaceResultsSubmissionEnabled`.
+   */
+  useOnDeviceWorkflow?: boolean;
+  /**
+   * Load the video-selfie face workflow (`SelfieWithAggregationMetrics`, the
+   * frame-aggregation best-shot pipeline used by the video-selfie flow)
+   * instead of the default quality-metrics selfie workflow. Mutually exclusive
+   * with `useOnDeviceWorkflow`.
+   */
+  videoSelfie?: boolean;
+}
+interface FacePositionConstraints {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+interface FaceDetectionThresholds {
+  brightnessThreshold: number;
+  blurrinessThreshold: number;
+  tiltRotationAngleThreshold: number;
+  minMagicCropSize: number;
+  autocaptureInterval: number;
+  minFaceQualityScore: number;
+  faceOcclusionThreshold: number;
+  /**
+   * Milliseconds the C++ workflow waits after `onGetReady` fires before
+   * triggering autocapture. Mirrors V1's `getReadyDelay` (2000 ms) — without
+   * it, autocapture can fire on the first quality-passing frame, before the
+   * front camera has finished locking focus, producing blurry captures that
+   * the on-device quality model rejects.
+   */
+  getReadyDelay: number;
+  /**
+   * Milliseconds over which face-detection results are aggregated before the
+   * autocapture decision. Mirrors V1's `framesAggregationInterval` (2000 ms).
+   */
+  framesAggregationInterval: number;
+  /**
+   * Minimum consecutive frames with a detected face required before
+   * autocapture can trigger. Mirrors V1's `minFramesWithFace` (3).
+   */
+  minFramesWithFace: number;
+}
+interface FaceAttributesThresholds {
+  headwearThreshold: number;
+  lensesThreshold: number;
+  closedEyesThreshold: number;
+  maskThreshold: number;
+}
+interface FaceChecksConfig {
+  lenses: boolean;
+  mask: boolean;
+  closedEyes: boolean;
+  headWear: boolean;
+  occlusion: boolean;
+}
+interface FaceData {
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  rightEye: {
+    x: number;
+    y: number;
+  };
+  leftEye: {
+    x: number;
+    y: number;
+  };
+  noseTip: {
+    x: number;
+    y: number;
+  };
+  rightMouthCorner: {
+    x: number;
+    y: number;
+  };
+  leftMouthCorner: {
+    x: number;
+    y: number;
+  };
+  pitch: number;
+  yaw: number;
+  roll: number;
+}
+type FaceCoordinates = {
+  rightEyeX: number;
+  rightEyeY: number;
+  leftEyeX: number;
+  leftEyeY: number;
+  noseTipX: number;
+  noseTipY: number;
+  rightMouthX: number;
+  rightMouthY: number;
+  mouthX: number;
+  mouthY: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+interface FaceDetectionCallbacks {
+  onFarAway?: () => void;
+  onTooClose?: () => void;
+  onTooManyFaces?: () => void;
+  onNoFace?: () => void;
+  onCapture?: (canvas: IncodeCanvas, faceCoordinates: FaceCoordinates) => void;
+  onGetReady?: () => void;
+  onGetReadyFinished?: () => void;
+  onCenterFace?: () => void;
+  onDark?: () => void;
+  onBlur?: () => void;
+  onFaceAngle?: () => void;
+  /**
+   * Fires on **every** processed frame that contains at least one detected
+   * face, with the freshly-computed face data (pitch/yaw/roll/landmarks).
+   *
+   * Use `onFaceData` when you need a dense per-frame signal for live UI
+   * feedback — e.g. the Personhood avatar that mirrors head pose. The
+   * default capture pipeline does not subscribe to this, so consumers
+   * that don't need per-frame data pay no cost.
+   *
+   * `frameSize` is the source frame's pixel dimensions. Optional so
+   * existing single-arg consumers keep working (TypeScript callback
+   * variance handles it). Personhood uses it to compute an
+   * orientation-invariant face-size ratio for distance-aware smoothing.
+   */
+  onFaceData?: (face: FaceData, frameSize?: {
+    width: number;
+    height: number;
+  }) => void;
+  onLenses?: () => void;
+  onMask?: () => void;
+  onEyesClosed?: () => void;
+  onHeadWear?: () => void;
+  onSwitchToManualCapture?: () => void;
+  onFaceOccluded?: () => void;
+}
+/**
+ * Capability interface for face detection and selfie capture.
+ * Extends the base ML provider capability with face-detection specific methods.
+ */
+interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionConfig> {
+  /**
+   * Sets callbacks for face detection events.
+   * @param callbacks - Object containing callback functions for various detection events
+   */
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  /**
+   * Sets position constraints for face detection.
+   * @param constraints - Bounding box constraints for valid face position
+   */
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  /**
+   * Sets detection thresholds for quality checks.
+   * @param thresholds - Threshold values for various quality metrics
+   */
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  /**
+   * Sets thresholds for face attribute detection.
+   * @param thresholds - Threshold values for attribute detection (headwear, lenses, etc.)
+   */
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  /**
+   * Enables or disables specific face checks.
+   * @param config - Configuration for which checks to enable
+   */
+  setChecksEnabled(config: FaceChecksConfig): void;
+  /**
+   * Sets video selfie mode.
+   * @param enabled - Whether to enable video selfie mode
+   */
+  setVideoSelfieMode(enabled: boolean): void;
+  /**
+   * Manually triggers the `onCapture` callback registered via
+   * `setCallbacks`, using the best-quality frame the provider has
+   * seen so far (or the most recent processed frame as a fallback).
+   * Used by callers that want to complete a capture flow without
+   * waiting for WASM's own autocapture criteria — e.g. Personhood's
+   * "complete with far-away face" path, where the user may be too
+   * small in frame for autocapture to ever fire but a verdict
+   * (likely lower-confidence) is still desired.
+   *
+   * No-op when no frame is available at all (camera hasn't produced
+   * a single decoded frame yet) or when no `onCapture` callback was
+   * registered.
+   */
+  forceCapture(): void;
+  /**
+   * @deprecated Unsupported since ml-wasm-kit v2.14.49-post1; scheduled for
+   * removal in 3.0.0. Calls fail deterministically without passing the canvas
+   * to native code. Use `ICameraCycleCapability.captureProtectedFrame` (the
+   * protected camera cycle's manual capture) instead.
+   */
+  processPhoto(canvas: HTMLCanvasElement): void;
+  /**
+   * POSTs the staged on-device face-results JSON to `/omni/add/face-results`.
+   * The C++ side encrypts the body via `SessionEncryptor` and routes through
+   * the WASM `WebClient`, so the SDK's WebClient must be initialized first
+   * (consumers calling this must configure `setup({ apiURL, wasm })`).
+   */
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+}
+//#endregion
+//#region ../infra/src/avatar/faceFeed.d.ts
+/**
+ * A tiny per-frame pub/sub channel for the Incode WASM pipeline's `FaceData`.
+ *
+ * The parked `incode-2d` avatar drives the cosmetic avatar from the **existing** Incode face-detection
+ * pipeline (no second MediaPipe model). The detection pipeline lives in core's
+ * detection actor, while the avatar lives in the avatar actor — so the avatar is
+ * *fed* `FaceData` through this channel rather than running its own model.
+ *
+ * Deliberately NOT routed through XState events/context: the pipeline emits
+ * ~10×/s, and assigning that into context would re-run `mapState` and notify all
+ * manager subscribers 10×/s — needless churn that could itself regress UI perf.
+ * The feed is a plain emitter passed as input to both actors (detection
+ * publishes, the avatar source subscribes); nothing else observes it.
+ *
+ * Strictly read-only w.r.t. the authoritative pipeline — the feed only forwards
+ * data the pipeline already computed; it never influences detection/autocapture.
+ */
+interface FaceFeedReader {
+  /** Subscribe to per-frame faces. Returns an unsubscribe function. */
+  subscribe(listener: (face: FaceData) => void): () => void;
+  /** The most recently published face, or null if none yet. */
+  getLatest(): FaceData | null;
+  /**
+   * Subscribe to the coarse "eyes closed" pulse — the only real eye signal the
+   * Incode pipeline exposes (a threshold event, both eyes, fired only when the
+   * closed-eyes check is enabled via `validateClosedEyes`). The avatar uses it
+   * to drive a real blink. Returns an unsubscribe function.
+   */
+  onEyesClosed(listener: () => void): () => void;
+}
+interface FaceFeed extends FaceFeedReader {
+  publish(face: FaceData): void;
+  /** Fire the eyes-closed pulse (from the detection pipeline's threshold event). */
+  signalEyesClosed(): void;
+}
+//#endregion
+//#region ../infra/src/capabilities/IFaceAvatarCapability.d.ts
+/**
+ * Caller-supplied overrides. Any omitted field falls back to the default
+ * CDN layout (see `avatar/avatarDefaults.ts`). `basePath`/`version` rewrite
+ * the whole directory; the individual `*Path` fields win over both.
+ */
+interface AvatarAssetsOverrides {
+  basePath?: string;
+  version?: string;
+  mediapipeModulePath?: string;
+  mediapipeWasmPath?: string;
+  faceLandmarkerModelPath?: string;
+  vrmModelPath?: string;
+}
+/**
+ * Verdict cue an avatar can reflect: `detecting` (working) / `success` / `error`.
+ * Pose-driven 2D avatars colour the face accordingly (green wink / red frown);
+ * avatars without a verdict visual (VRM, privacy-lens) treat `setState` as a no-op.
+ * Driven by the host module (selfie capture outcome, personhood verdict).
+ */
+type AvatarFaceState = 'detecting' | 'success' | 'error';
+//#endregion
+//#region src/internal/avatar/createFaceAvatar.d.ts
+/**
+ * Shared face-avatar dispatch — the single code path BOTH the selfie module
+ * (`faceCapture` runAvatar actor) and the public `@incodetech/core/avatar` facade
+ * use, so every camera module mounts avatars the same way. Lives in `internal/`
+ * (not `modules/`) because `internal/` may not import from `modules/`; the public
+ * `modules/avatar` entry is a thin re-export of this. See
+ * docs/features/FACE_AVATAR.md.
+ *
+ * Public catalog of shippable face avatars. Each id maps to a lazily-loaded
+ * provider, so a module only pays the bundle cost of the avatar it picks:
+ *  - `avatar-3d`    → 3D VRM character, MediaPipe-tracked (premium look).
+ *  - `avatar-2d`    → stylized 2D "satin" face, MediaPipe-tracked. Also the
+ *                     personhood avatar.
+ *  - `privacy-lens` → WebGL frosted-glass lens over the real video (no tracking).
+ *
+ * (The Incode-data 2D avatar is parked — kept in infra, not in the public
+ * catalog. See docs/features/FACE_AVATAR.md → Parked: the Incode-data avatar.)
+ */
+type AvatarId = 'avatar-3d' | 'avatar-2d' | 'privacy-lens';
+interface FaceAvatarOptions {
+  /** Which avatar to render. */
+  variant: AvatarId;
+  /** The already-acquired camera stream (the host module owns it). */
+  stream: MediaStream;
+  /** Runtime asset overrides (MediaPipe wasm/model, VRM); defaults to the CDN layout. */
+  assets?: AvatarAssetsOverrides;
+  /** Upper bound on the avatar's internal detect/render loop (default 30). */
+  maxFps?: number;
+  /** Initial verdict cue; defaults to `detecting`. */
+  initialState?: AvatarFaceState;
+}
+interface FaceAvatarHandle {
+  /** The canvas to mount in place of the live video. */
+  readonly canvas: HTMLCanvasElement;
+  /** Push a verdict cue (no-op for avatars without a verdict visual). */
+  setState(state: AvatarFaceState): void;
+  /** Tear down the loop, model and hidden decode video. */
+  stop(): void;
+}
+/**
+ * Mounts a cosmetic face avatar: lazy-loads the chosen provider, starts it on the
+ * given stream, and returns a handle to mount the canvas + push verdict cues. The
+ * avatar is **cosmetic-only** — it never feeds the authoritative
+ * detection/quality/liveness/upload pipeline.
+ */
+declare function createFaceAvatar(options: FaceAvatarOptions): Promise<FaceAvatarHandle>;
+//#endregion
+export { MLProviderConfig as _, AvatarAssetsOverrides as a, FaceAttributesThresholds as c, FaceDetectionCallbacks as d, FaceDetectionConfig as f, IMLProviderCapability as g, IFaceDetectionCapability as h, createFaceAvatar as i, FaceChecksConfig as l, FacePositionConstraints as m, FaceAvatarHandle as n, AvatarFaceState as o, FaceDetectionThresholds as p, FaceAvatarOptions as r, FaceFeed as s, AvatarId as t, FaceCoordinates as u, WebApiHostRequestConfig as v, IncodeCanvas as y };

package/dist/cross-document-data-match.esm.js

@@ -1,2 +1,2 @@
-import { n as createCrossDocumentDataMatchManagerFromActor, r as crossDocumentDataMatchMachine, t as createCrossDocumentDataMatchManager } from "./crossDocumentDataMatchManager-CGT0V6RV.esm.js";
+import { n as createCrossDocumentDataMatchManagerFromActor, r as crossDocumentDataMatchMachine, t as createCrossDocumentDataMatchManager } from "./crossDocumentDataMatchManager-QMOGwHXR.esm.js";
 export { createCrossDocumentDataMatchManager, createCrossDocumentDataMatchManagerFromActor, crossDocumentDataMatchMachine };

package/dist/{crossDocumentDataMatchManager-CGT0V6RV.esm.js → crossDocumentDataMatchManager-QMOGwHXR.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";

package/dist/curp-validation.d.ts

@@ -1,4 +1,4 @@
-import { a as CurpValidationActor, c as CurpValidationErrors, d as GenerateCurpFieldDef, f as GenerateCurpFieldType, i as createCurpValidationManagerFromActor, l as CurpValidationRule, n as CurpValidationState, o as curpValidationMachine, p as GenerateCurpForm, r as createCurpValidationManager, s as CurpValidationConfig, t as CurpValidationManager, u as EnterCurpFieldDef } from "./curpValidationManager-DVGr7Fq7.js";
+import { a as CurpValidationActor, c as CurpValidationErrors, d as GenerateCurpFieldDef, f as GenerateCurpFieldType, i as createCurpValidationManagerFromActor, l as CurpValidationRule, n as CurpValidationState, o as curpValidationMachine, p as GenerateCurpForm, r as createCurpValidationManager, s as CurpValidationConfig, t as CurpValidationManager, u as EnterCurpFieldDef } from "./curpValidationManager-SSKNrm5Z.js";
 //#region src/modules/curp-validation/curpValidationUtils.d.ts
 type MexicanState = {
   value: string;

package/dist/curp-validation.esm.js

@@ -1,3 +1,3 @@
-import { i as mexicanStates, n as ENTER_CURP_FIELD, r as GENERATE_CURP_FIELDS, t as curpValidationMachine } from "./curpValidationStateMachine-Ds7KMacK.esm.js";
-import { n as createCurpValidationManagerFromActor, t as createCurpValidationManager } from "./curpValidationManager-6Nmkn5u1.esm.js";
+import { i as mexicanStates, n as ENTER_CURP_FIELD, r as GENERATE_CURP_FIELDS, t as curpValidationMachine } from "./curpValidationStateMachine-DvUPC_8S.esm.js";
+import { n as createCurpValidationManagerFromActor, t as createCurpValidationManager } from "./curpValidationManager-D1ppROcF.esm.js";
 export { ENTER_CURP_FIELD, GENERATE_CURP_FIELDS, createCurpValidationManager, createCurpValidationManagerFromActor, curpValidationMachine, mexicanStates };

package/dist/{curpValidationManager-6Nmkn5u1.esm.js → curpValidationManager-D1ppROcF.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as curpValidationMachine } from "./curpValidationStateMachine-Ds7KMacK.esm.js";
+import { t as curpValidationMachine } from "./curpValidationStateMachine-DvUPC_8S.esm.js";
 //#region src/modules/curp-validation/curpValidationActor.ts
 function createCurpValidationActor(options) {
 	return createActor(curpValidationMachine, { input: { config: options.config } }).start();

package/dist/{curpValidationManager-DVGr7Fq7.d.ts → curpValidationManager-SSKNrm5Z.d.ts}

@@ -1,7 +1,7 @@
 import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import "./Actor-iTq7YY48.js";
-import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
+import { i as FlowModuleConfig } from "./types-Do5rEXij.js";
 //#region src/modules/curp-validation/types.d.ts
 type CurpValidationConfig = FlowModuleConfig['CURP_VALIDATION'] & {
   /** Maximum validation retries before auto-advancing. @default 1 */

package/dist/{curpValidationStateMachine-Ds7KMacK.esm.js → curpValidationStateMachine-DvUPC_8S.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 //#region src/modules/curp-validation/curpValidationUtils.ts

package/dist/custom-fields.d.ts

@@ -1,114 +1,2 @@
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-//#region src/modules/custom-fields/types.d.ts
-type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
-type CustomField = {
-  name: string;
-  alias: string;
-  type: CustomFieldType;
-};
-type CustomFieldsConfig = {
-  title: string;
-  customFields: CustomField[];
-};
-//#endregion
-//#region src/modules/custom-fields/customFieldsStateMachine.d.ts
-type CustomFieldsResult = 'success' | 'failed';
-declare const customFieldsMachine: any;
-//#endregion
-//#region src/modules/custom-fields/customFieldsActor.d.ts
-type CreateCustomFieldsActorOptions = {
-  config: CustomFieldsConfig;
-};
-//#endregion
-//#region src/modules/custom-fields/customFieldsManager.d.ts
-/**
- * A `CustomField` enriched with a computed `label` for display.
- * Label is derived from `alias` when present, otherwise auto-formatted from `name`.
- */
-type MappedCustomField = CustomField & {
-  label: string;
-};
-/** Custom fields manager is in initial state, waiting for `load()` to be called */
-type CustomFieldsIdleState = {
-  status: 'idle';
-};
-/**
- * Ready for field input — use `setField()` and `submit()`
- * @property title - Form title from configuration
- * @property customFields - Field definitions with computed display labels
- * @property canSubmit - True when all non-boolean fields have a non-empty value
- */
-type CustomFieldsInputtingState = {
-  status: 'inputting';
-  title: string;
-  customFields: MappedCustomField[];
-  canSubmit: boolean;
-};
-/** Fields are being submitted to the backend */
-type CustomFieldsSubmittingState = {
-  status: 'submitting';
-  title: string;
-};
-/** API call succeeded — success page is visible for ~3 s before finishing */
-type CustomFieldsSuccessState = {
-  status: 'success';
-};
-/** Custom fields flow complete. `result` indicates whether the API call succeeded or failed. */
-type CustomFieldsFinishedState = {
-  status: 'finished';
-  result: CustomFieldsResult | null;
-};
-/**
- * Union of all possible custom fields manager states.
- */
-type CustomFieldsState = CustomFieldsIdleState | CustomFieldsInputtingState | CustomFieldsSubmittingState | CustomFieldsSuccessState | CustomFieldsFinishedState;
-/**
- * Creates a custom fields manager for headless or UI-driven usage.
- *
- * @param options - Configuration options
- * @param options.config - Custom fields configuration (title + field definitions)
- *
- * @returns Custom fields manager with state, API methods, and subscription
- *
- * @example Headless usage
- * ```typescript
- * const manager = createCustomFieldsManager({
- *   config: {
- *     title: 'Additional Information',
- *     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
- *   },
- * });
- *
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * manager.setField('company', 'Incode');
- * manager.submit();
- * manager.stop();
- * ```
- */
-declare function createCustomFieldsManager(options: CreateCustomFieldsActorOptions): Manager<CustomFieldsState> & {
-  /**
-   * Initializes the custom fields flow.
-   * Transitions from 'idle' to 'inputting'.
-   * Must be called before any other method.
-   */
-  load(): void;
-  /**
-   * Updates the value of a single field.
-   * Should be called when state is 'inputting'.
-   *
-   * @param name - The field name (matches CustomField.name)
-   * @param value - The field value (string, number, or boolean)
-   */
-  setField(name: string, value: string | number | boolean): void;
-  /**
-   * Submits all custom field values to the backend.
-   * Transitions to 'submitting', then 'finished' regardless of outcome.
-   */
-  submit(): void;
-};
-/** Type representing a custom fields manager instance. */
-type CustomFieldsManager = ReturnType<typeof createCustomFieldsManager>;
-//#endregion
-export { type CustomField, type CustomFieldType, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type MappedCustomField, createCustomFieldsManager, customFieldsMachine };
+import { a as createCustomFieldsManagerFromActor, c as customFieldsMachine, d as CustomFieldsConfig, i as createCustomFieldsManager, l as CustomField, n as CustomFieldsState, o as CustomFieldsActor, r as MappedCustomField, s as CustomFieldsValidationErrors, t as CustomFieldsManager, u as CustomFieldType } from "./customFieldsManager-8-W2KY4n.js";
+export { type CustomField, type CustomFieldType, type CustomFieldsActor, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type CustomFieldsValidationErrors, type MappedCustomField, createCustomFieldsManager, createCustomFieldsManagerFromActor, customFieldsMachine };