@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/{consentManager-B4PMGXW-.d.ts → consentManager-uhDPdU6i.d.ts}

@@ -1,7 +1,7 @@
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-import * as xstate1009 from "xstate";
-
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
 //#region src/modules/consent/types.d.ts
 type ConsentConfig = {
   combinedConsents?: string;
@@ -37,7 +37,7 @@ type ConsentContext = {
 type ConsentInput = {
   config: ConsentConfig;
 };
-declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
+declare const consentMachine: StateMachine<ConsentContext, {
   type: "LOAD";
 } | {
   type: "TOGGLE_CHECKBOX";
@@ -49,130 +49,128 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
 } | {
   type: "RESET";
 }, {
-  [x: string]: xstate1009.ActorRefFromLogic<xstate1009.PromiseActorLogic<FetchCombinedConsentResponse, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<FetchCombinedConsentResponse, {
     consentId: string;
     language?: string;
-  }, xstate1009.EventObject>> | xstate1009.ActorRefFromLogic<xstate1009.PromiseActorLogic<void, {
+  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
     languageConsentId: string;
     checkboxes: ConsentCheckbox[];
-  }, xstate1009.EventObject>> | undefined;
-}, xstate1009.Values<{
+  }, EventObject>> | undefined;
+}, Values<{
   fetchConsent: {
     src: "fetchConsent";
-    logic: xstate1009.PromiseActorLogic<FetchCombinedConsentResponse, {
+    logic: PromiseActorLogic<FetchCombinedConsentResponse, {
       consentId: string;
       language?: string;
-    }, xstate1009.EventObject>;
+    }, EventObject>;
     id: string | undefined;
   };
   submitConsent: {
     src: "submitConsent";
-    logic: xstate1009.PromiseActorLogic<void, {
+    logic: PromiseActorLogic<void, {
       languageConsentId: string;
       checkboxes: ConsentCheckbox[];
-    }, xstate1009.EventObject>;
+    }, EventObject>;
     id: string | undefined;
   };
-}>, xstate1009.Values<{
+}>, Values<{
   setError: {
     type: "setError";
-    params: xstate1009.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   clearError: {
     type: "clearError";
-    params: xstate1009.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   resetContext: {
     type: "resetContext";
-    params: xstate1009.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   setConsentData: {
     type: "setConsentData";
-    params: xstate1009.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   toggleCheckbox: {
     type: "toggleCheckbox";
-    params: xstate1009.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
 }>, {
   type: "canSubmit";
   params: unknown;
-}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "display", string, ConsentInput, xstate1009.NonReducibleUnknown, xstate1009.EventObject, xstate1009.MetaObject, {
+}, never, "error" | "idle" | "finished" | "submitting" | "loading" | "display", string, ConsentInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "consent";
   readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
+  readonly context: ({ input }: {
     spawn: {
       <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
         src: "fetchConsent";
-        logic: xstate1009.PromiseActorLogic<FetchCombinedConsentResponse, {
+        logic: PromiseActorLogic<FetchCombinedConsentResponse, {
           consentId: string;
           language?: string;
-        }, xstate1009.EventObject>;
+        }, EventObject>;
         id: string | undefined;
-      } extends infer T ? T extends {
+      } extends (infer T) ? T extends {
         src: "fetchConsent";
-        logic: xstate1009.PromiseActorLogic<FetchCombinedConsentResponse, {
+        logic: PromiseActorLogic<FetchCombinedConsentResponse, {
           consentId: string;
           language?: string;
-        }, xstate1009.EventObject>;
+        }, EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate1009.ConditionalRequired<[options?: ({
+      } ? ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate1009.InputFrom<T["logic"]> | undefined;
+        input?: InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1009.RequiredActorOptions<T>]: unknown }) | undefined], xstate1009.IsNotNever<xstate1009.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
         src: "submitConsent";
-        logic: xstate1009.PromiseActorLogic<void, {
+        logic: PromiseActorLogic<void, {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];
-        }, xstate1009.EventObject>;
+        }, EventObject>;
         id: string | undefined;
-      } extends infer T_1 ? T_1 extends {
+      } extends (infer T_1) ? T_1 extends {
         src: "submitConsent";
-        logic: xstate1009.PromiseActorLogic<void, {
+        logic: PromiseActorLogic<void, {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];
-        }, xstate1009.EventObject>;
+        }, EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate1009.ConditionalRequired<[options?: ({
+      } ? ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate1009.InputFrom<T_1["logic"]> | undefined;
+        input?: InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate1009.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate1009.IsNotNever<xstate1009.RequiredActorOptions<T_1>>> : never : never : never)): xstate1009.ActorRefFromLogic<xstate1009.GetConcreteByKey<xstate1009.Values<{
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
         fetchConsent: {
           src: "fetchConsent";
-          logic: xstate1009.PromiseActorLogic<FetchCombinedConsentResponse, {
+          logic: PromiseActorLogic<FetchCombinedConsentResponse, {
             consentId: string;
             language?: string;
-          }, xstate1009.EventObject>;
+          }, EventObject>;
           id: string | undefined;
         };
         submitConsent: {
           src: "submitConsent";
-          logic: xstate1009.PromiseActorLogic<void, {
+          logic: PromiseActorLogic<void, {
             languageConsentId: string;
             checkboxes: ConsentCheckbox[];
-          }, xstate1009.EventObject>;
+          }, EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate1009.AnyActorLogic>(src: TLogic, ...[options]: xstate1009.ConditionalRequired<[options?: ({
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate1009.InputFrom<TLogic> | undefined;
+        input?: InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1009.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1009.IsNotNever<xstate1009.RequiredLogicInput<TLogic>>>): xstate1009.ActorRefFromLogic<TLogic>;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
     };
     input: ConsentInput;
-    self: xstate1009.ActorRef<xstate1009.MachineSnapshot<ConsentContext, {
+    self: ActorRef<MachineSnapshot<ConsentContext, {
       type: "LOAD";
     } | {
       type: "TOGGLE_CHECKBOX";
@@ -183,7 +181,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
       type: "RETRY";
     } | {
       type: "RESET";
-    }, Record<string, xstate1009.AnyActorRef | undefined>, xstate1009.StateValue, string, unknown, any, any>, {
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "TOGGLE_CHECKBOX";
@@ -194,7 +192,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
       type: "RETRY";
     } | {
       type: "RESET";
-    }, xstate1009.AnyEventObject>;
+    }, AnyEventObject>;
   }) => {
     config: ConsentConfig;
     title: string;
@@ -216,9 +214,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
       readonly invoke: {
         readonly id: "fetchConsent";
         readonly src: "fetchConsent";
-        readonly input: ({
-          context
-        }: {
+        readonly input: ({ context }: {
           context: ConsentContext;
           event: {
             type: "LOAD";
@@ -232,7 +228,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
           } | {
             type: "RESET";
           };
-          self: xstate1009.ActorRef<xstate1009.MachineSnapshot<ConsentContext, {
+          self: ActorRef<MachineSnapshot<ConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -243,7 +239,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate1009.AnyActorRef>, xstate1009.StateValue, string, unknown, any, any>, {
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -254,7 +250,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate1009.AnyEventObject>;
+          }, AnyEventObject>;
         }) => {
           consentId: string;
           language: string | undefined;
@@ -288,9 +284,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
       readonly invoke: {
         readonly id: "submitConsent";
         readonly src: "submitConsent";
-        readonly input: ({
-          context
-        }: {
+        readonly input: ({ context }: {
           context: ConsentContext;
           event: {
             type: "LOAD";
@@ -304,7 +298,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
           } | {
             type: "RESET";
           };
-          self: xstate1009.ActorRef<xstate1009.MachineSnapshot<ConsentContext, {
+          self: ActorRef<MachineSnapshot<ConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -315,7 +309,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate1009.AnyActorRef>, xstate1009.StateValue, string, unknown, any, any>, {
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -326,7 +320,7 @@ declare const consentMachine: xstate1009.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate1009.AnyEventObject>;
+          }, AnyEventObject>;
         }) => {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];

package/dist/{consentStateMachine-BOkVFiU7.esm.js → consentStateMachine-WD-S-Yhs.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, 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 { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/consent/consentServices.ts
 async function fetchCombinedConsent(consentId, language, signal) {
 	if (!consentId) throw new Error("Combined consent id is required");
@@ -19,7 +19,6 @@ async function submitCombinedConsent(params, signal) {
 	const res = await api.post(endpoints.signCombinedConsent, params, { signal });
 	if (!res.ok) throw new Error(`POST ${endpoints.signCombinedConsent} failed: ${res.status} ${res.statusText}`);
 }
-
 //#endregion
 //#region src/modules/consent/consentStateMachine.ts
 function toCheckboxRecord(checkboxes) {
@@ -149,6 +148,5 @@ const consentMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { consentMachine as t };
+export { consentMachine as t };

package/dist/{cpf-16m_cGAM.esm.js → cpf-BIADjddF.esm.js}

@@ -33,6 +33,5 @@ function validateCPF(cpfString) {
 	if (cpf.charAt(10) !== secondDigit.toString()) return false;
 	return true;
 }
-
 //#endregion
-export { validateCPF as t };
+export { validateCPF as t };

package/dist/createFaceAvatar-BEj18KXi.d.ts

@@ -0,0 +1,50 @@
+import { n as AvatarFaceState, t as AvatarAssetsOverrides } from "./IFaceAvatarCapability-BrL19G0s.js";
+//#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 { createFaceAvatar as i, FaceAvatarHandle as n, FaceAvatarOptions as r, AvatarId as t };

package/dist/createFaceAvatar-DQKaRise.esm.js

@@ -0,0 +1,103 @@
+import { i as markAvatarTimeline } from "./avatarStats-CdUOb3VD.esm.js";
+//#region src/internal/avatar/createFaceAvatar.ts
+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");
+		default: throw new Error(`Unknown avatar variant: ${String(variant)}`);
+	}
+}
+/**
+* Lazy-load the provider MODULE for an avatar id (each in its own chunk),
+* MEMOIZED per variant: the warm-up (tutorial) and the capture-time
+* `runAvatar` would otherwise race two concurrent dynamic imports of the same
+* specifier — wasteful in browsers and actively wrong under vitest, whose
+* module mocker can serve the REAL module to the second in-flight import. A
+* failed import is evicted so a later attempt can retry (flaky network).
+*/
+const providerModuleCache = /* @__PURE__ */ new Map();
+function loadProviderModule(variant) {
+	let cached = providerModuleCache.get(variant);
+	if (!cached) {
+		cached = importProviderModule(variant);
+		cached.catch(() => {
+			if (providerModuleCache.get(variant) === cached) providerModuleCache.delete(variant);
+		});
+		providerModuleCache.set(variant, cached);
+	}
+	return cached;
+}
+/** Lazy-load and instantiate the provider for an avatar id. */
+async function loadProvider(variant) {
+	return (await loadProviderModule(variant)).createProvider();
+}
+/**
+* Pre-capture warm-up (ENG-49806 AC#1): fire-and-forget, safe to call from a
+* machine action (e.g. tutorial entry). Preloads the provider chunk for every
+* variant; for `avatar-2d` it additionally boots the tracking worker and runs
+* the MediaPipe bring-up (module + ~3.7MB model download + WASM compile — the
+* seconds-long part on low-tier devices) WITHOUT camera or canvas, so
+* tracking engages near-instantly when capture starts instead of losing the
+* race against a fast capture. Idempotent; never throws; touches no media
+* (cosmetic-only by construction).
+*/
+let avatar2dWarmRequested = false;
+function warmFaceAvatar(options) {
+	markAvatarTimeline("warm-request");
+	loadProviderModule(options.variant).catch(() => {});
+	if (options.variant === "avatar-2d") {
+		avatar2dWarmRequested = true;
+		import("./avatar2dWarm-DqucNFX4.esm.js").then((mod) => mod.warmAvatar2D({
+			mediapipeModulePath: options.assets?.mediapipeModulePath,
+			mediapipeWasmPath: options.assets?.mediapipeWasmPath,
+			faceLandmarkerModelPath: options.assets?.faceLandmarkerModelPath
+		})).catch(() => {});
+	}
+}
+/**
+* Dispose an un-adopted warm-up (terminal machine states). No-op when the
+* warm worker was already consumed by a capture, or none exists. Gated on a
+* warm having been REQUESTED this session: the terminal-state machine action
+* calls this unconditionally, and importing `avatar2dWarm` here would pull
+* the whole avatar-2d chunk at flow end for every flow — including
+* OPTION_NONE on the low-tier devices the gate exists to protect.
+*/
+function releaseFaceAvatarWarmup() {
+	if (!avatar2dWarmRequested) return;
+	import("./avatar2dWarm-DqucNFX4.esm.js").then((mod) => mod.releaseAvatar2DWarmup()).catch(() => {});
+}
+/**
+* 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.
+*/
+async function createFaceAvatar(options) {
+	markAvatarTimeline("create-start");
+	const provider = await loadProvider(options.variant);
+	try {
+		await provider.start(options.stream, {
+			assets: options.assets,
+			maxFps: options.maxFps
+		});
+		markAvatarTimeline("create-ready");
+		if (options.initialState) provider.setState?.(options.initialState);
+	} catch (error) {
+		provider.stop();
+		throw error;
+	}
+	return {
+		get canvas() {
+			return provider.getCanvas();
+		},
+		setState(state) {
+			provider.setState?.(state);
+		},
+		stop() {
+			provider.stop();
+		}
+	};
+}
+//#endregion
+export { releaseFaceAvatarWarmup as n, warmFaceAvatar as r, createFaceAvatar as t };

package/dist/cross-document-data-match.d.ts

@@ -1,28 +1,4 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.d.ts
-type CrossDocumentDataMatchIdleState = {
-  status: 'idle';
-};
-type CrossDocumentDataMatchProcessingState = {
-  status: 'processing';
-};
-type CrossDocumentDataMatchFinishedState = {
-  status: 'finished';
-};
-type CrossDocumentDataMatchState = CrossDocumentDataMatchIdleState | CrossDocumentDataMatchProcessingState | CrossDocumentDataMatchFinishedState;
-declare function createCrossDocumentDataMatchManager(): Manager<CrossDocumentDataMatchState> & {
-  /**
-   * Starts cross-document comparison (spinner + backend processing).
-   */
-  load(): void;
-};
-type CrossDocumentDataMatchManager = ReturnType<typeof createCrossDocumentDataMatchManager>;
-//#endregion
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchStateMachine.d.ts
-declare const crossDocumentDataMatchMachine: any;
-//#endregion
+import { a as CrossDocumentDataMatchActor, i as createCrossDocumentDataMatchManagerFromActor, n as CrossDocumentDataMatchState, o as crossDocumentDataMatchMachine, r as createCrossDocumentDataMatchManager, t as CrossDocumentDataMatchManager } from "./crossDocumentDataMatchManager-Dq8Z3SOg.js";
 //#region src/modules/cross-document-data-match/types.d.ts
 /**
  * Configuration for the cross-document data match module.
@@ -32,4 +8,4 @@ declare const crossDocumentDataMatchMachine: any;
  */
 type CrossDocumentDataMatchConfig = Record<string, never>;
 //#endregion
-export { type CrossDocumentDataMatchConfig, type CrossDocumentDataMatchManager, type CrossDocumentDataMatchState, createCrossDocumentDataMatchManager, crossDocumentDataMatchMachine };
+export { type CrossDocumentDataMatchActor, type CrossDocumentDataMatchConfig, type CrossDocumentDataMatchManager, type CrossDocumentDataMatchState, createCrossDocumentDataMatchManager, createCrossDocumentDataMatchManagerFromActor, crossDocumentDataMatchMachine };

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

@@ -1,71 +1,2 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, l as createManager, s as createActor, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as sleep } from "./ITimerCapability-DJ73P4RK.esm.js";
-
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchServices.ts
-/** Minimum spinner duration (ms), aligned with SDK v1 `ProcessCrossDocumentData`. */
-const MIN_DISPLAY_MS = 3e3;
-async function processCrossDocumentDataMatch(signal) {
-	const [res] = await Promise.all([api.post(endpoints.processCrossDocumentDataMatch, {}, { signal }), sleep(MIN_DISPLAY_MS)]);
-	if (!res.ok) throw new Error(`POST ${endpoints.processCrossDocumentDataMatch} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchStateMachine.ts
-const crossDocumentDataMatchMachine = setup({
-	types: {
-		context: {},
-		events: {}
-	},
-	actors: { processCrossDocumentDataMatch: fromPromise(async ({ signal }) => {
-		return processCrossDocumentDataMatch(signal);
-	}) }
-}).createMachine({
-	id: "crossDocumentDataMatch",
-	initial: "idle",
-	context: {},
-	states: {
-		idle: { on: { LOAD: { target: "processing" } } },
-		processing: { invoke: {
-			id: "processCrossDocumentDataMatch",
-			src: "processCrossDocumentDataMatch",
-			onDone: { target: "finished" },
-			onError: { target: "finished" }
-		} },
-		finished: { type: "final" }
-	}
-});
-
-//#endregion
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchActor.ts
-function createCrossDocumentDataMatchActor() {
-	return createActor(crossDocumentDataMatchMachine).start();
-}
-
-//#endregion
-//#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.ts
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	if (typedSnapshot.matches("processing")) return { status: "processing" };
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return { load() {
-		actor.send({ type: "LOAD" });
-	} };
-}
-function createCrossDocumentDataMatchManager() {
-	return createManager({
-		actor: createCrossDocumentDataMatchActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.crossDocumentDataMatch)
-	});
-}
-
-//#endregion
-export { createCrossDocumentDataMatchManager, crossDocumentDataMatchMachine };
+import { n as createCrossDocumentDataMatchManagerFromActor, r as crossDocumentDataMatchMachine, t as createCrossDocumentDataMatchManager } from "./crossDocumentDataMatchManager-OmYvyung.esm.js";
+export { createCrossDocumentDataMatchManager, createCrossDocumentDataMatchManagerFromActor, crossDocumentDataMatchMachine };

package/dist/crossDocumentDataMatchManager-Dq8Z3SOg.d.ts

@@ -0,0 +1,41 @@
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchStateMachine.d.ts
+declare const crossDocumentDataMatchMachine: any;
+type CrossDocumentDataMatchMachine = typeof crossDocumentDataMatchMachine;
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchActor.d.ts
+type CrossDocumentDataMatchActor = ActorRefFrom<CrossDocumentDataMatchMachine>;
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.d.ts
+type CrossDocumentDataMatchIdleState = {
+  status: 'idle';
+};
+type CrossDocumentDataMatchProcessingState = {
+  status: 'processing';
+};
+type CrossDocumentDataMatchFinishedState = {
+  status: 'finished';
+};
+type CrossDocumentDataMatchState = CrossDocumentDataMatchIdleState | CrossDocumentDataMatchProcessingState | CrossDocumentDataMatchFinishedState;
+declare function createCrossDocumentDataMatchManager(): Manager<CrossDocumentDataMatchState> & {
+  /**
+   * Starts cross-document comparison (spinner + backend processing).
+   */
+  load(): void;
+};
+/**
+ * Creates a cross-document-data-match manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createCrossDocumentDataMatchManagerFromActor(actor: CrossDocumentDataMatchActor): Manager<CrossDocumentDataMatchState> & {
+  /**
+   * Starts cross-document comparison (spinner + backend processing).
+   */
+  load(): void;
+};
+type CrossDocumentDataMatchManager = ReturnType<typeof createCrossDocumentDataMatchManager>;
+//#endregion
+export { CrossDocumentDataMatchActor as a, createCrossDocumentDataMatchManagerFromActor as i, CrossDocumentDataMatchState as n, crossDocumentDataMatchMachine as o, createCrossDocumentDataMatchManager as r, CrossDocumentDataMatchManager as t };