@incodetech/core 0.0.0-dev-20260715-b208c5e1 → 0.0.0-dev-20260715-dcc78bcd

package/dist/Actor-iTq7YY48.d.ts

@@ -0,0 +1 @@
+import "./StateMachine-EDpYWy0i.js";

package/dist/{BrowserStorageProvider-CBXGCHnK.esm.js → BrowserStorageProvider-P6aUarE9.esm.js}

@@ -50,6 +50,5 @@ var BrowserStorageProvider = class {
 		localStorage.clear();
 	}
 };
-
 //#endregion
-export { BrowserStorageProvider as t };
+export { BrowserStorageProvider as t };

package/dist/{BrowserTimerProvider-CHloo0eQ.esm.js → BrowserTimerProvider-BXhgNxLt.esm.js}

@@ -17,6 +17,5 @@ var BrowserTimerProvider = class BrowserTimerProvider {
 		clearInterval(handle);
 	}
 };
-
 //#endregion
-export { BrowserTimerProvider as t };
+export { BrowserTimerProvider as t };

package/dist/{BrowserVisibilityObserverProvider-B04zvOXW.esm.js → BrowserVisibilityObserverProvider-sJclps4C.esm.js}

@@ -3,7 +3,6 @@ function setWasmDsFlagSync(enabled) {
 	if (typeof localStorage === "undefined") return;
 	localStorage.setItem("ds", enabled ? "1" : "0");
 }
-
 //#endregion
 //#region ../infra/src/providers/browser/BrowserVisibilityObserverProvider.ts
 var BrowserVisibilityObserverProvider = class {
@@ -20,6 +19,5 @@ var BrowserVisibilityObserverProvider = class {
 		};
 	}
 };
-
 //#endregion
-export { setWasmDsFlagSync as n, BrowserVisibilityObserverProvider as t };
+export { setWasmDsFlagSync as n, BrowserVisibilityObserverProvider as t };

package/dist/{Face2DProvider-TeN1Xqr0.esm.js → Face2DProvider-xWUeSJZI.esm.js}

@@ -1,6 +1,5 @@
-import { t as createHiddenVideoElement } from "./video-DXf5H9rY.esm.js";
-import { i as dtAlpha, n as asRvfc, r as createFaceLandmarker, t as MAX_EMA_DT_MS } from "./mediapipeShared-B-RiRyLN.esm.js";
-
+import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
+import { n as createFaceLandmarker, r as dtAlpha, t as asRvfc } from "./mediapipeShared-B0iQQ5k7.esm.js";
 //#region ../infra/src/avatar/2d-default-avatar/assets.ts
 /**
 * 2D avatar MediaPipe asset resolution — **self-contained** (no shared
@@ -23,14 +22,13 @@ function resolveAvatar2DAssets(overrides) {
 		faceLandmarkerModelPath: valid(overrides?.faceLandmarkerModelPath) ? overrides.faceLandmarkerModelPath : DEFAULT_FACE_LANDMARKER_MODEL_URL
 	};
 }
-
 //#endregion
 //#region ../infra/src/avatar/renderers/SatinSmileyRenderer.ts
 const SPRITE = 512;
 const HEAD_CX = 256;
 const HEAD_CY = 256;
 const HEAD_R = 150;
-const HALO_R = HEAD_R + 28;
+const HALO_R = 178;
 const EYE_Y = 218;
 const EYE_DX = 56;
 const EYE_RX = 12;
@@ -189,7 +187,7 @@ var SatinSmileyRenderer = class {
 		ctx.translate(s / 2 + slideX, s / 2 + slideY);
 		ctx.rotate(frame.headEuler.z);
 		ctx.scale(scale * k, scale * k);
-		ctx.translate(-SPRITE / 2, -SPRITE / 2);
+		ctx.translate(-512 / 2, -512 / 2);
 		if (faceAlpha > .02) {
 			ctx.globalAlpha = faceAlpha;
 			this.drawBall(ctx);
@@ -198,7 +196,7 @@ var SatinSmileyRenderer = class {
 			ctx.save();
 			ctx.translate(HEAD_CX, HEAD_CY);
 			ctx.scale(1 - Math.abs(yaw) * .24, 1 - Math.abs(pitch) * .12);
-			ctx.translate(-HEAD_CX, -HEAD_CY);
+			ctx.translate(-256, -256);
 			ctx.translate(featX, featY);
 			const feat = rgb(this.eased.feature);
 			let blinkL = clamp$1(frame.blink.left, 0, 1);
@@ -208,7 +206,7 @@ var SatinSmileyRenderer = class {
 				blinkR = .85;
 			}
 			this.drawEye(ctx, HEAD_CX - EYE_DX, EYE_Y, blinkL, feat);
-			this.drawEye(ctx, HEAD_CX + EYE_DX, EYE_Y, blinkR, feat);
+			this.drawEye(ctx, 312, EYE_Y, blinkR, feat);
 			this.drawNose(ctx, feat);
 			let mouth = Math.max(REST_SMILE, clamp$1(frame.smile ?? 0, 0, 1));
 			if (state === "success") mouth = 1;
@@ -297,11 +295,10 @@ var SatinSmileyRenderer = class {
 		ctx.lineCap = "round";
 		ctx.beginPath();
 		ctx.moveTo(HEAD_CX - MOUTH_HALF, cy - lift);
-		ctx.quadraticCurveTo(HEAD_CX, cy + curve, HEAD_CX + MOUTH_HALF, cy - lift);
+		ctx.quadraticCurveTo(HEAD_CX, cy + curve, 300, cy - lift);
 		ctx.stroke();
 	}
 };
-
 //#endregion
 //#region ../infra/src/avatar/2d-default-avatar/pose.ts
 const AVATAR2D_NEUTRAL_POSE = {
@@ -361,13 +358,6 @@ const AVATAR2D_DEADZONE = {
 };
 const MEDIAN_WINDOW = 7;
 /**
-* Below this face-size ratio the detector emits sporadic single-frame outlier
-* spikes ("the avatar jumps") that the deadzone (idle-only) and the EMA (delays,
-* doesn't reject) both miss; run the {@link Median} first in that regime. At/above
-* it, the face is near and exp smoothing alone is enough. (FACE_AVATAR.md → Pose pipeline.)
-*/
-const MEDIAN_FACE_RATIO = .35;
-/**
 * Single-axis rolling-window median for outlier rejection. Returns the latest
 * sample until the window fills (no start-up lag spike), then the middle of the
 * sorted window. The buffer stays in insertion order so `shift()` evicts the
@@ -510,7 +500,6 @@ function blinkMouthFromBlendshapes(result) {
 		smile: (smileL + smileR) / 2
 	};
 }
-
 //#endregion
 //#region ../infra/src/avatar/2d-default-avatar/Face2DProvider.ts
 /**
@@ -582,7 +571,7 @@ var Avatar2DProvider = class {
 			if (this.stopped) return;
 			this.scheduleNextFrame();
 			if (now - this.lastFrameAt < this.minFrameIntervalMs) return;
-			const dtMs = clamp(this.lastFrameAt > 0 ? now - this.lastFrameAt : this.minFrameIntervalMs, 1, MAX_EMA_DT_MS);
+			const dtMs = clamp(this.lastFrameAt > 0 ? now - this.lastFrameAt : this.minFrameIntervalMs, 1, 100);
 			this.lastFrameAt = now;
 			const video = this.videoHandle?.element;
 			if (!video || video.readyState < 2 || !this.landmarker) {
@@ -744,7 +733,7 @@ var Avatar2DProvider = class {
 	* reset the buffers (no stale samples across distance regimes).
 	*/
 	applyMedian(raw) {
-		if (!(raw.faceSizeRatio !== void 0 && raw.faceSizeRatio < MEDIAN_FACE_RATIO)) {
+		if (!(raw.faceSizeRatio !== void 0 && raw.faceSizeRatio < .35)) {
 			this.medYaw.reset();
 			this.medPitch.reset();
 			this.medRoll.reset();
@@ -819,6 +808,5 @@ function copyPoseInto(dst, src) {
 function createProvider() {
 	return new Avatar2DProvider();
 }
-
 //#endregion
-export { createProvider };
+export { createProvider };

package/dist/{createFaceAvatar-BjBu2CrU.d.ts → FaceDetectionProvider-BHweGBEM.d.ts}

@@ -1,7 +1,7 @@
-import { t as IncodeCanvas } from "./canvas-COIxuirO.js";
-
+import { n as WasmPipeline } from "./warmup-Dv2alr2-.js";
+import { r as IncodeCanvas } from "./deepsightService-CR-CYdka.js";
+import { a as MLProviderConfig, i as IMLProviderCapability } from "./IStorageCapability-B8IGxCwe.js";
 //#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`
@@ -14,65 +14,6 @@ type WebApiHostRequestConfig = {
   timeout?: number;
 };
 //#endregion
-//#region ../infra/src/capabilities/IMLProviderCapability.d.ts
-/**
- * Base configuration shared by all ML provider capabilities.
- */
-interface MLProviderConfig {
-  /** Path to the WASM binary */
-  wasmPath?: string;
-  /** Path to the SIMD-optimized WASM binary (optional) */
-  wasmSimdPath?: string;
-  /** Path to the WASM glue code (paired with `wasmPath`) */
-  glueCodePath?: string;
-  /**
-   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
-   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
-   */
-  glueCodeSimdPath?: string;
-  /** Whether to use SIMD optimizations (default: true) */
-  useSimd?: boolean;
-  /**
-   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
-   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
-   */
-  modelsBasePath?: string;
-}
-/**
- * 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.
@@ -291,111 +232,119 @@ interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionCo
   postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
 }
 //#endregion
-//#region ../infra/src/avatar/faceFeed.d.ts
+//#region ../infra/src/wasm/WasmPipelineType.d.ts
+declare enum WasmPipelineType {
+  IdBlurGlarePipeline = 0,
+  IdBarcodeAndTextQualityPipeline = 1,
+  IdVideoSelfiePipeline = 2,
+  SelfieWithAggregationMetrics = 3,
+  SelfieWithQualityMetrics = 4,
+  OnDeviceSelfieWorkflow = 5
+}
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.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.
+ * Base configuration for WASM providers
  */
-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;
+interface BaseWasmConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code (paired with `wasmPath`) */
+  glueCodePath?: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
   /**
-   * 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.
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
    */
-  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;
+  modelsBasePath?: string;
 }
-//#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.
+ * Base provider class that abstracts common WASM functionality.
+ * This serves as a foundation for specific ML capability providers
+ * like FaceDetectionProvider and IdCaptureProvider.
  */
-interface AvatarAssetsOverrides {
-  basePath?: string;
-  version?: string;
-  mediapipeModulePath?: string;
-  mediapipeWasmPath?: string;
-  faceLandmarkerModelPath?: string;
-  vrmModelPath?: string;
+declare abstract class BaseWasmProvider {
+  private _isInitialized;
+  protected pipelineType: WasmPipelineType | undefined;
+  /**
+   * Creates a new BaseWasmProvider
+   * @param pipelineType - The WASM pipeline type this provider uses
+   */
+  constructor(pipelineType?: WasmPipelineType);
+  /**
+   * Returns whether this provider has been initialized.
+   */
+  get initialized(): boolean;
+  protected getPipelineType(): WasmPipelineType;
+  /**
+   * Initializes the provider by ensuring WASM is loaded
+   * @param config - Provider configuration
+   * @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+   */
+  protected initializeBase(config: BaseWasmConfig, pipeline: WasmPipeline): Promise<void>;
+  /**
+   * Ensures the provider is initialized before performing operations.
+   * @throws Error if not initialized
+   */
+  protected ensureInitialized(): void;
+  /**
+   * Processes a frame through the WASM pipeline
+   * @param image - Image data to process
+   * @returns The pipeline result (type depends on pipeline - WASM returns any)
+   */
+  protected processFrameWasm(image: ImageData): Promise<any>;
+  abstract 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>;
 }
-/**
- * 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;
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  private onFaceDataCallback;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  /**
+   * Last-registered onCapture callback — captured into a private
+   * field so `forceCapture()` (called from outside the WASM-callback
+   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
+   * this on each invocation, so the field always reflects the
+   * current consumer.
+   */
+  private currentOnCaptureWrapper;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  applyDefaults(autocaptureInterval?: number): void;
+  setAutocaptureInterval(interval: number): void;
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  setChecksEnabled(config: FaceChecksConfig): void;
+  setVideoSelfieMode(enabled: boolean): void;
+  forceCapture(): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
 }
-/**
- * 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 };
+export { FaceData as i, BaseWasmProvider as n, FaceCoordinates as r, FaceDetectionProvider as t };

package/dist/IFaceAvatarCapability-BrL19G0s.d.ts

@@ -0,0 +1,23 @@
+//#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
+export { AvatarFaceState as n, AvatarAssetsOverrides as t };

package/dist/IStorageCapability-B8IGxCwe.d.ts

@@ -0,0 +1,131 @@
+//#region ../infra/src/capabilities/IMLProviderCapability.d.ts
+/**
+ * Base configuration shared by all ML provider capabilities.
+ */
+interface MLProviderConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code (paired with `wasmPath`) */
+  glueCodePath?: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
+   */
+  modelsBasePath?: string;
+}
+/**
+ * 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/IRecordingCapability.d.ts
+type RecordingPublisher = {
+  getStreamId: () => string | undefined;
+  replaceVideoTrack: (track: MediaStreamTrack) => Promise<void>;
+  destroy: () => void;
+};
+type RecordingConnection = {
+  sessionId: string | undefined;
+  publisher: RecordingPublisher;
+  disconnect: () => Promise<void>;
+};
+type RecordingConnectionEvents = {
+  onSessionConnected?: (sessionId: string | undefined) => void;
+  onSessionDisconnected?: (sessionId: string | undefined) => void;
+  onSessionException?: (params: {
+    name?: string;
+    message?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherCreated?: (params: {
+    streamId?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherError?: (params: {
+    message?: string;
+    sessionId?: string;
+    streamId?: string;
+  }) => void;
+};
+type ConnectRecordingParams = {
+  sessionToken: string;
+  stream: MediaStream;
+  events?: RecordingConnectionEvents;
+};
+type IRecordingCapability = {
+  /**
+   * Connects to a recording session and publishes the provided media stream.
+   * Returns a connection handle that can be disconnected and used to manage the publisher.
+   */
+  connect: (params: ConnectRecordingParams) => Promise<RecordingConnection>;
+};
+//#endregion
+//#region ../infra/src/capabilities/IStorageCapability.d.ts
+/**
+ * Storage capability interface for abstracting storage operations.
+ * Enables swapping between browser localStorage and future WASM-based storage.
+ */
+interface IStorageCapability {
+  /**
+   * Retrieves a value from storage.
+   * @param key - The storage key
+   * @returns The stored value or null if not found
+   */
+  get<T>(key: string): Promise<T | null>;
+  /**
+   * Stores a value in storage.
+   * @param key - The storage key
+   * @param value - The value to store (will be serialized)
+   */
+  set<T>(key: string, value: T): Promise<void>;
+  /**
+   * Removes a value from storage.
+   * @param key - The storage key to remove
+   */
+  remove(key: string): Promise<void>;
+  /**
+   * Clears all values from storage.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+export { MLProviderConfig as a, IMLProviderCapability as i, IRecordingCapability as n, RecordingConnection as r, IStorageCapability as t };

package/dist/{ITimerCapability-G7lQg-be.esm.js → ITimerCapability-DgdDzp8G.esm.js}

@@ -2,6 +2,5 @@
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 //#endregion
-export { sleep as t };
+export { sleep as t };

package/dist/{Manager-DE5DydXZ.d.ts → Manager-CQQ99QOI.d.ts}

@@ -1,3 +1,4 @@
+import "./StateMachine-EDpYWy0i.js";
 //#region ../infra/src/manager/Manager.d.ts
 /**
  * Base manager interface providing state access, subscriptions, and lifecycle control.

package/dist/{MotionSensorProvider-BkHKMCPE.esm.js → MotionSensorProvider-DYvM90IX.esm.js}

@@ -299,6 +299,5 @@ var MotionSensorProvider = class MotionSensorProvider {
 		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
 	}
 };
-
 //#endregion
-export { MotionSensorProvider as t };
+export { MotionSensorProvider as t };

package/dist/{OpenViduRecordingProvider-xR5osKzW.esm.js → OpenViduRecordingProvider-Du98qevC.esm.js}

@@ -1,5 +1,4 @@
-import { t as loadOpenVidu } from "./openviduLazy-CuGqb-8Q.esm.js";
-
+import { loadOpenVidu } from "./openviduLazy-CCDpFWg1.esm.js";
 //#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
 function createHiddenContainer() {
 	const id = `inc_rec_${Math.random().toString(36).slice(2)}`;
@@ -82,6 +81,5 @@ var OpenViduRecordingProvider = class {
 		};
 	}
 };
-
 //#endregion
-export { OpenViduRecordingProvider };
+export { OpenViduRecordingProvider };

package/dist/{PrivacyLensProvider-CqlsCaJv.esm.js → PrivacyLensProvider-BrYSd1dr.esm.js}

@@ -1,5 +1,4 @@
-import { t as createHiddenVideoElement } from "./video-DXf5H9rY.esm.js";
-
+import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
 //#region ../infra/src/avatar/privacy-lens/privacyLensShaders.ts
 /** Starting point; tuned live via the privacy-lens demo sliders. */
 const PRIVACY_LENS_DEFAULTS = {
@@ -103,7 +102,6 @@ void main() {
 
   gl_FragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
 }`;
-
 //#endregion
 //#region ../infra/src/avatar/privacy-lens/PrivacyLensProvider.ts
 /**
@@ -334,6 +332,5 @@ var PrivacyLensProvider = class {
 function createProvider() {
 	return new PrivacyLensProvider();
 }
-
 //#endregion
-export { createProvider };
+export { createProvider };