@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{setup-CmA2apmN.d.ts → setup-DywQeePQ.d.ts}

@@ -1,8 +1,15 @@
-import { n as WasmPipeline } from "./warmup-Dd0iq6KF.js";
-import { s as TransactionalRiskIntelligenceSetupConfig } from "./index-BAyZ8_iI.js";
-
+import { n as WasmPipeline } from "./warmup-Dv2alr2-.js";
+import { s as TransactionalRiskIntelligenceSetupConfig } from "./index-BKOWUhxG.js";
+import { c as FeatureManagementRedactedUserInfo } from "./IFeatureManagementCapability-DdEUp6tB.js";
+//#region src/internal/environment/environment.d.ts
+/**
+ * Coarse deployment tier for feature-management targeting.
+ * See `SetupOptions.environment` in `../../setup.ts` for the public-facing contract
+ * (locked by the first `setup()` call that supplies it).
+ */
+type EnvironmentTier = 'development' | 'staging' | 'production';
+//#endregion
 //#region src/setup.d.ts
-
 /**
  * WASM warmup configuration. Path fields are optional; omitted values resolve to the Incode CDN defaults.
  */
@@ -71,6 +78,10 @@ type EncryptionOptions = {
    */
   mgf1?: 'sha1' | 'sha256';
 };
+type FlowSetup = false | {
+  preload?: boolean;
+  mergeConfig?: boolean;
+};
 /**
  * Configuration options for the SDK setup.
  */
@@ -88,6 +99,19 @@ type SetupOptions = {
    * mounting `<incode-flow>`).
    */
   token?: string;
+  /**
+   * Video Selfie module configuration — see {@link VideoSelfieSetupOptions}.
+   *
+   * `videoSelfie.apiURL` points the module's multipart video upload at the
+   * dedicated video-selfie-service (e.g.
+   * `https://video-selfie-service.stage.incodetest.com`).
+   *
+   * **Testing/special-env override only — omit it in production.** When
+   * omitted, the upload endpoints (`/v1/video-upload/*`) resolve against the
+   * main `apiURL` like every other endpoint, and the production service mesh
+   * (Istio) routes them to the video-selfie-service.
+   */
+  videoSelfie?: VideoSelfieSetupOptions;
   /** Custom headers to include in all requests */
   customHeaders?: Record<string, string>;
   /** Request timeout in milliseconds */
@@ -184,6 +208,17 @@ type SetupOptions = {
    * Default: `true` (fingerprint submission enabled).
    */
   fingerprint?: boolean;
+  /**
+   * Controls Flow-backed standalone module configuration.
+   * - Omit or `{}`: supplied config is used verbatim; omitted config resolves
+   *   from Flow when the module mounts.
+   * - `{ preload: true }`: await Flow prefetch during setup without changing
+   *   how supplied config is handled.
+   * - `{ mergeConfig: true }`: merge supplied partial config over Flow config
+   *   when the module mounts.
+   * - `false`: never resolve standalone module config from Flow.
+   */
+  flow?: FlowSetup;
   /**
    * Disables the browser devtools detector for local development. When `true`,
    * the detector is **not** started, so devtools no longer gets repeatedly
@@ -218,6 +253,153 @@ type SetupOptions = {
    * collection should begin.
    */
   tri?: TransactionalRiskIntelligenceSetupConfig;
+  /**
+   * TrueSight diagnostics — Incode-internal SDK-health telemetry
+   * (engineering-only dashboard, not customer analytics). During a session
+   * the SDK buffers sanitized, structured diagnostic breadcrumbs (module
+   * outcomes, error codes, timings — never PII, never captured images) and,
+   * at the session terminal, uploads ONE encrypted record to the Incode
+   * diagnostics backend. Used by Incode to debug customer-reported capture
+   * issues. Fire-and-forget and fail-open: it adds no retries, no blocking
+   * work, and can never affect the host flow.
+   *
+   * - `enabled` — set `false` to opt out entirely (no collection, no
+   *   subscriptions, no upload). Default: `true` (native SDK parity). Also
+   *   subject to a server-side kill-switch; an explicit server `false` stops
+   *   collection remotely regardless of this option.
+   *
+   * Decided by the first `setup()` call of the SDK lifecycle; later `setup()`
+   * calls cannot re-enable or disable it mid-session. Call `reset()` to start
+   * a new lifecycle with a different value.
+   */
+  trueSight?: {
+    enabled?: boolean;
+  };
+  /**
+   * Enables feature management. Loaded during `setup()` as a separate dynamic chunk,
+   * never part of the main `@incodetech/core` bundle.
+   *
+   * Uses no customer API key: identity starts with the client SDK's
+   * auto-generated StableID plus the deployment tier from `environment`
+   * below (plus `clientExperimentId`, when supplied), and is enriched over
+   * the session lifecycle with `hashed_onboarding_id` (once the session
+   * initializes), `flow_id` (from the flow response), or `workflow_id` (from
+   * the workflow configuration). The applicable enrichments are awaited
+   * before the first module renders. Read gates/experiments via
+   * `@incodetech/core/feature-management`.
+   *
+   * Boot is awaited as part of `setup()` and never throws. Session, flow, and
+   * workflow loaders then await their identity enrichments before the first
+   * module renders, so evaluations never use a stale identity.
+   *
+   * Accepts:
+   * - `true` (default) or omitted — enabled, no `clientExperimentId` or
+   *   privacy flags.
+   * - `false` — full opt-out: no chunk is fetched and no
+   *   feature-management network traffic occurs. Reads from
+   *   `@incodetech/core/feature-management` still work when disabled; they
+   *   simply resolve to their documented defaults (gates `false`,
+   *   experiments fall back, dynamic configs `null`).
+   * - `{ clientExperimentId?, disableStableId?, disablePersistence? }` —
+   *   enabled with the given identity/privacy configuration.
+   *
+   * **Only the first `setup()` call that enables feature management may
+   * initialize it.** Every later enabled `setup()` call logs a `console.error`
+   * and is ignored, regardless of whether its values match. For multi-step
+   * boot, call `setup()` once and activate the token later with
+   * `initializeSession({ token })`. Call `reset()` before starting a new SDK
+   * lifecycle.
+   *
+   * Default: `true`.
+   */
+  featureManagement?: boolean | FeatureManagementSetupOptions;
+  /**
+   * Coarse deployment tier for feature-management (Statsig) targeting: one of
+   * `'development'`, `'staging'`, or `'production'`. No finer granularity.
+   * Default: `'production'`.
+   *
+   * Used by the first enabled feature-management initialization only — see
+   * `featureManagement` above.
+   *
+   * No effect when `featureManagement` is `false`.
+   *
+   * @example
+   * ```ts
+   * await setup({ apiURL, environment: 'staging' });
+   * ```
+   */
+  environment?: EnvironmentTier;
+};
+/**
+ * The `videoSelfie` option for {@link SetupOptions}.
+ */
+type VideoSelfieSetupOptions = {
+  /**
+   * Base URL (origin) of the dedicated video-selfie-service that handles the
+   * Video Selfie module's multipart video upload. The service authenticates
+   * with the same session token as the main API — no extra credentials
+   * needed. Only the Video Selfie module's recording upload uses this;
+   * nothing else is affected.
+   *
+   * Testing/special-env override: in production the main `apiURL` serves the
+   * upload paths too (the service mesh routes `/v1/video-upload/*` to the
+   * video-selfie-service), so this should normally stay unset. Set it only
+   * where that routing doesn't exist — e.g. stage, or a self-hosted
+   * environment that exposes the service on its own origin.
+   */
+  apiURL?: string;
+};
+/**
+ * Object form of the `featureManagement` option for {@link SetupOptions}.
+ * The boolean shorthand (`featureManagement: true`) is equivalent to `{}`.
+ */
+type FeatureManagementSetupOptions = {
+  /**
+   * Integrator-scoped randomization/targeting unit, registered as
+   * the `client_experiment_id` custom ID during initialization.
+   * Agreed with your Incode representative — use it to
+   * target or bucket gates/experiments for a specific integrator (e.g. a
+   * pilot rollout), independent of the per-user/per-session identity built
+   * up from StableID, `hashed_onboarding_id`, `flow_id`, and `workflow_id`.
+   */
+  clientExperimentId?: string;
+  /**
+   * Prevents the feature-management from generating a StableID for this
+   * user at all. The strongest privacy control: with no StableID and
+   * no other randomization-unit ID yet known, evaluations
+   * resolve to control/default until `hashed_onboarding_id`, `flow_id`, or
+   * `workflow_id` arrives later in the session. Default: `false` (StableID
+   * enabled).
+   */
+  disableStableId?: boolean;
+  /**
+   * Prevents the feature-management from persisting any state
+   * (including the StableID) to local storage (`disableStorage`) — identity
+   * is in-memory only for the lifetime of the page and is never linkable
+   * across page loads. Trades away feature-management's local bootstrap cache, so
+   * every session re-fetches on boot. Default: `false` (persistence
+   * enabled).
+   */
+  disablePersistence?: boolean;
+  /**
+   * Arbitrary attributes attached to the feature-management user for
+   * targeting rules and analytics. Unlike `clientExperimentId`, these are not randomization units
+   * — they don't bucket experiments, but gate/experiment targeting conditions can read
+   * them, and they annotate exposure/event logs.
+   *
+   * Set once at boot; enriching later is not currently supported here.
+   * Avoid putting PII or secrets in these values — they reach the
+   * feature-management backend's logs as-is.
+   */
+  custom?: Record<string, unknown>;
+  /**
+   * Which auto-collected feature-management user fields to blank out before
+   * sending them to the provider. Covers every field the underlying SDK
+   * collects except `custom`/`customIDs` (already caller-controlled above).
+   * `ip` and `country` are redacted by default; pass `false` for either to
+   * send it, or `true` for any other field to redact it too.
+   */
+  redactedUserInfo?: FeatureManagementRedactedUserInfo;
 };
 /**
  * Initializes the SDK with the provided configuration.

package/dist/signature.d.ts

@@ -1,96 +1,2 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-
-//#region src/modules/signature/types.d.ts
-/**
- * Configuration options for Signature.
- */
-type SignatureConfig = {
-  type?: string;
-  /**
-   * Optional header title for both steps. When omitted, the UI uses per-step defaults
-   * (“Draw your signature”).
-   */
-  title?: string;
-  /**
-   * Optional subtitle for both steps. When omitted, the UI uses the default finger/mouse copy.
-   * Backend field name: `subTitle` (capital T).
-   */
-  subTitle?: string;
-  /**
-   * When true, uploads base64 via Omni `addSignature` v2 JSON body.
-   * When false (default), uploads JPEG bytes (`image/jpeg`).
-   */
-  sendBase64?: boolean;
-  /**
-   * Optional fill behind the drawing area (e.g. hex, `rgb()`, or a CSS variable).
-   * When omitted, the default themed surface from the signature UI is used.
-   */
-  canvasBackgroundColor?: string;
-  /**
-   * Optional maximum stroke width for the pen, in CSS pixels (passed to `SignaturePad` as `maxWidth`).
-   * When omitted, the pad uses its default sizing.
-   */
-  penStrokeWidth?: number;
-  /**
-   * Optional ink color (e.g. hex, `rgb()`, or `var(--token)` resolved where supported).
-   * When omitted, the default signature pen color from theme tokens is used.
-   */
-  penColor?: string;
-  /**
-   * Optional border color for the drawing area (same format as `penColor`).
-   * When omitted, the default input border token from the signature UI is used.
-   */
-  canvasBorderColor?: string;
-};
-/** Response body from Omni add-signature endpoints. */
-type AddSignatureResponse = {
-  image: string | Blob;
-  type: string;
-};
-//#endregion
-//#region src/modules/signature/signatureStateMachine.d.ts
-
-declare const signatureMachine: any;
-//#endregion
-//#region src/modules/signature/signatureActor.d.ts
-type CreateSignatureActorOptions = {
-  config: SignatureConfig;
-};
-//#endregion
-//#region src/modules/signature/signatureManager.d.ts
-
-type SignatureIdleState = {
-  status: 'idle';
-};
-type SignatureCaptureState = {
-  status: 'capture';
-  title: string | undefined;
-  subtitle: string | undefined;
-  canContinue: boolean;
-};
-type SignatureSubmittingState = {
-  status: 'submitting';
-};
-type SignatureFinishedState = {
-  status: 'finished';
-  result: AddSignatureResponse | undefined;
-};
-type SignatureErrorState = {
-  status: 'error';
-  error: string;
-};
-type SignatureSuccessState = {
-  status: 'success';
-};
-type SignatureState = SignatureIdleState | SignatureCaptureState | SignatureSubmittingState | SignatureFinishedState | SignatureErrorState | SignatureSuccessState;
-declare function createSignatureManager(options: CreateSignatureActorOptions): Manager<SignatureState> & {
-  load(): void;
-  setSignatureValid(isValid: boolean): void;
-  /** Exported image (base64 string or JPEG Blob) from the canvas; starts the upload actor. */
-  submit(image: string | Blob): void;
-};
-type SignatureManager = ReturnType<typeof createSignatureManager>;
-//#endregion
-export { type SignatureCaptureState, type SignatureConfig, type SignatureManager, type SignatureState, createSignatureManager, signatureMachine };
+import { a as createSignatureManagerFromActor, c as SignatureConfig, i as createSignatureManager, n as SignatureManager, o as SignatureActor, r as SignatureState, s as signatureMachine, t as SignatureCaptureState } from "./signatureManager-DGBSWz2_.js";
+export { type SignatureActor, type SignatureCaptureState, type SignatureConfig, type SignatureManager, type SignatureState, createSignatureManager, createSignatureManagerFromActor, signatureMachine };

package/dist/signature.esm.js

@@ -1,108 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as signatureMachine } from "./signatureStateMachine-CdhlMih-.esm.js";
-
-//#region src/modules/signature/signatureActor.ts
-function createSignatureActor(options) {
-	return createActor(signatureMachine, { input: { config: options.config } }).start();
-}
-
-//#endregion
-//#region src/modules/signature/signatureManager.ts
-/**
-* Maps a signature state-machine snapshot to the exact Figma "Tracked
-* Events" screen name. Returned strings are the Figma-verbatim absolute
-* analytics path (module prefix included), emitted as-is on `event.screen`
-* by `createManagerInstrumentation`'s `getEventScreenName` path. See
-* `docs/patterns/INSTRUMENTATION.md`.
-*
-* Source of truth: Electronic Signature Figma file → Tracked Events canvas
-* (`https://www.figma.com/design/kUsDigsC8Mq1WobTewF0R6/Electronic-Signature---Latest-Design?node-id=4268-3602`).
-* Section names are taken as canonical — note the canvas mixes
-* `eSign.writeSignature.*` for the `default`/`completed` screens with
-* `eSign.writeYourSignature.success` (without the `Signature` collapse) for
-* the success surface; both spellings are preserved verbatim.
-*
-* State → screen mapping rationale:
-*
-* - `idle`/`captureSignature` collapse to `eSign.writeSignature.default` —
-*   the state machine stays in `captureSignature` throughout drawing (stroke
-*   validity changes via `SIGNATURE_CHANGED` are context-only and don't fire
-*   a new `screenOpened`). The `eSign.writeSignature.completed` Figma surface
-*   is therefore the post-submit "signed canvas while we wait for the API"
-*   surface, mapped to `submittingSignature`.
-* - `success`/`finished` both map to `eSign.writeYourSignature.success` so
-*   the terminal `finished` state stays on the visible success canvas rather
-*   than falling back to the generic `<module>.finished` default.
-* - `error` is intentionally unmapped — the Figma canvas does not define a
-*   dedicated error screen yet. The adapter falls back to the generic
-*   `eSign.error` default, which `errorTriggered` consumers can still
-*   correlate against the error payload.
-*/
-function getSignatureScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "idle":
-		case "captureSignature": return "eSign.writeSignature.default";
-		case "submittingSignature": return "eSign.writeSignature.completed";
-		case "success":
-		case "finished": return "eSign.writeYourSignature.success";
-		default: return;
-	}
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("captureSignature")) return {
-		status: "capture",
-		title: context.config.title,
-		subtitle: context.config.subTitle,
-		canContinue: context.isValid
-	};
-	if (typedSnapshot.matches("submittingSignature")) return { status: "submitting" };
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	if (typedSnapshot.matches("finished")) return {
-		status: "finished",
-		result: context.signatureSubmitResult
-	};
-	if (typedSnapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Upload failed"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor, trackElementClicked }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		setSignatureValid(isValid) {
-			actor.send({
-				type: "SIGNATURE_CHANGED",
-				isValid
-			});
-		},
-		submit(image) {
-			trackElementClicked?.("continue");
-			actor.send({
-				type: "CONTINUE",
-				image
-			});
-		}
-	};
-}
-function createSignatureManager(options) {
-	return createManager({
-		actor: createSignatureActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.signature, { getEventScreenName: getSignatureScreenName })
-	});
-}
-
-//#endregion
-export { createSignatureManager, signatureMachine };
+import { t as signatureMachine } from "./signatureStateMachine-Cf73DGWO.esm.js";
+import { n as createSignatureManagerFromActor, t as createSignatureManager } from "./signatureManager-DdPgcmou.esm.js";
+export { createSignatureManager, createSignatureManagerFromActor, signatureMachine };

package/dist/signatureManager-DGBSWz2_.d.ts

@@ -0,0 +1,106 @@
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/signature/types.d.ts
+/**
+ * Configuration options for Signature.
+ */
+type SignatureConfig = {
+  type?: string;
+  /**
+   * Optional header title for both steps. When omitted, the UI uses per-step defaults
+   * (“Draw your signature”).
+   */
+  title?: string;
+  /**
+   * Optional subtitle for both steps. When omitted, the UI uses the default finger/mouse copy.
+   * Backend field name: `subTitle` (capital T).
+   */
+  subTitle?: string;
+  /**
+   * When true, uploads base64 via Omni `addSignature` v2 JSON body.
+   * When false (default), uploads JPEG bytes (`image/jpeg`).
+   */
+  sendBase64?: boolean;
+  /**
+   * Optional fill behind the drawing area (e.g. hex, `rgb()`, or a CSS variable).
+   * When omitted, the default themed surface from the signature UI is used.
+   */
+  canvasBackgroundColor?: string;
+  /**
+   * Optional maximum stroke width for the pen, in CSS pixels (passed to `SignaturePad` as `maxWidth`).
+   * When omitted, the pad uses its default sizing.
+   */
+  penStrokeWidth?: number;
+  /**
+   * Optional ink color (e.g. hex, `rgb()`, or `var(--token)` resolved where supported).
+   * When omitted, the default signature pen color from theme tokens is used.
+   */
+  penColor?: string;
+  /**
+   * Optional border color for the drawing area (same format as `penColor`).
+   * When omitted, the default input border token from the signature UI is used.
+   */
+  canvasBorderColor?: string;
+};
+/** Response body from Omni add-signature endpoints. */
+type AddSignatureResponse = {
+  image: string | Blob;
+  type: string;
+};
+//#endregion
+//#region src/modules/signature/signatureStateMachine.d.ts
+declare const signatureMachine: any;
+type SignatureMachine = typeof signatureMachine;
+//#endregion
+//#region src/modules/signature/signatureActor.d.ts
+type CreateSignatureActorOptions = {
+  config: SignatureConfig;
+};
+type SignatureActor = ActorRefFrom<SignatureMachine>;
+//#endregion
+//#region src/modules/signature/signatureManager.d.ts
+type SignatureIdleState = {
+  status: 'idle';
+};
+type SignatureCaptureState = {
+  status: 'capture';
+  title: string | undefined;
+  subtitle: string | undefined;
+  canContinue: boolean;
+};
+type SignatureSubmittingState = {
+  status: 'submitting';
+};
+type SignatureFinishedState = {
+  status: 'finished';
+  result: AddSignatureResponse | undefined;
+};
+type SignatureErrorState = {
+  status: 'error';
+  error: string;
+};
+type SignatureSuccessState = {
+  status: 'success';
+};
+type SignatureState = SignatureIdleState | SignatureCaptureState | SignatureSubmittingState | SignatureFinishedState | SignatureErrorState | SignatureSuccessState;
+declare function createSignatureManager(options: CreateSignatureActorOptions): Manager<SignatureState> & {
+  load(): void;
+  setSignatureValid(isValid: boolean): void;
+  /** Exported image (base64 string or JPEG Blob) from the canvas; starts the upload actor. */
+  submit(image: string | Blob): void;
+};
+/**
+ * Creates a signature manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or isolated UI rendering.
+ */
+declare function createSignatureManagerFromActor(actor: SignatureActor): Manager<SignatureState> & {
+  load(): void;
+  setSignatureValid(isValid: boolean): void;
+  /** Exported image (base64 string or JPEG Blob) from the canvas; starts the upload actor. */
+  submit(image: string | Blob): void;
+};
+type SignatureManager = ReturnType<typeof createSignatureManager>;
+//#endregion
+export { createSignatureManagerFromActor as a, SignatureConfig as c, createSignatureManager as i, SignatureManager as n, SignatureActor as o, SignatureState as r, signatureMachine as s, SignatureCaptureState as t };

package/dist/signatureManager-DdPgcmou.esm.js

@@ -0,0 +1,113 @@
+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 signatureMachine } from "./signatureStateMachine-Cf73DGWO.esm.js";
+//#region src/modules/signature/signatureActor.ts
+function createSignatureActor(options) {
+	return createActor(signatureMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/signature/signatureManager.ts
+/**
+* Maps a signature state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Returned strings are the Figma-verbatim absolute
+* analytics path (module prefix included), emitted as-is on `event.screen`
+* by `createManagerInstrumentation`'s `getEventScreenName` path. See
+* `docs/patterns/INSTRUMENTATION.md`.
+*
+* Source of truth: Electronic Signature Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/kUsDigsC8Mq1WobTewF0R6/Electronic-Signature---Latest-Design?node-id=4268-3602`).
+* Section names are taken as canonical — note the canvas mixes
+* `eSign.writeSignature.*` for the `default`/`completed` screens with
+* `eSign.writeYourSignature.success` (without the `Signature` collapse) for
+* the success surface; both spellings are preserved verbatim.
+*
+* State → screen mapping rationale:
+*
+* - `idle`/`captureSignature` collapse to `eSign.writeSignature.default` —
+*   the state machine stays in `captureSignature` throughout drawing (stroke
+*   validity changes via `SIGNATURE_CHANGED` are context-only and don't fire
+*   a new `screenOpened`). The `eSign.writeSignature.completed` Figma surface
+*   is therefore the post-submit "signed canvas while we wait for the API"
+*   surface, mapped to `submittingSignature`.
+* - `success`/`finished` both map to `eSign.writeYourSignature.success` so
+*   the terminal `finished` state stays on the visible success canvas rather
+*   than falling back to the generic `<module>.finished` default.
+* - `error` is intentionally unmapped — the Figma canvas does not define a
+*   dedicated error screen yet. The adapter falls back to the generic
+*   `eSign.error` default, which `errorTriggered` consumers can still
+*   correlate against the error payload.
+*/
+function getSignatureScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "idle":
+		case "captureSignature": return "eSign.writeSignature.default";
+		case "submittingSignature": return "eSign.writeSignature.completed";
+		case "success":
+		case "finished": return "eSign.writeYourSignature.success";
+		default: return;
+	}
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("captureSignature")) return {
+		status: "capture",
+		title: context.config.title,
+		subtitle: context.config.subTitle,
+		canContinue: context.isValid
+	};
+	if (typedSnapshot.matches("submittingSignature")) return { status: "submitting" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: context.signatureSubmitResult
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Upload failed"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setSignatureValid(isValid) {
+			actor.send({
+				type: "SIGNATURE_CHANGED",
+				isValid
+			});
+		},
+		/** Exported image (base64 string or JPEG Blob) from the canvas; starts the upload actor. */
+		submit(image) {
+			trackElementClicked?.("continue");
+			actor.send({
+				type: "CONTINUE",
+				image
+			});
+		}
+	};
+}
+function createSignatureManager(options) {
+	return createSignatureManagerFromActor(createSignatureActor(options));
+}
+/**
+* Creates a signature manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or isolated UI rendering.
+*/
+function createSignatureManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.signature, { getEventScreenName: getSignatureScreenName })
+	});
+}
+//#endregion
+export { createSignatureManagerFromActor as n, createSignatureManager as t };

package/dist/{signatureStateMachine-CdhlMih-.esm.js → signatureStateMachine-Cf73DGWO.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/signature/signatureServices.ts
 /**
 * Uploads a signature image to the Omni API.
@@ -20,7 +20,6 @@ async function addSignature(params, signal) {
 	if (!res.ok) throw new Error(`POST ${url} failed: ${res.status} ${res.statusText}`);
 	return res.data;
 }
-
 //#endregion
 //#region src/modules/signature/signatureStateMachine.ts
 function emptyCaptureState() {
@@ -109,6 +108,5 @@ const signatureMachine = setup({
 		error: {}
 	}
 });
-
 //#endregion
-export { signatureMachine as t };
+export { signatureMachine as t };