@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/setup-C5AITV8m.d.ts

@@ -1,254 +0,0 @@
-import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
-
-//#region src/setup.d.ts
-
-/**
- * WASM warmup configuration. Path fields are optional; omitted values resolve to the Incode CDN defaults.
- */
-type WasmConfig = {
-  /** 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;
-  /** Which pipelines to preload models for */
-  pipelines?: WasmPipeline[];
-  /**
-   * 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;
-};
-/**
- * Object form of the `encryption` option for {@link SetupOptions}. Reach for
- * this when you need to pin the OAEP MGF1 hash; the boolean shorthand
- * (`encryption: true`) is equivalent to `{}` and uses the SHA-1 default.
- *
- * Which value to pass is **dictated by the E2EE environment Incode has
- * provisioned for your account** — confirm with your Incode account team
- * before changing it.
- */
-type EncryptionOptions = {
-  /**
-   * OAEP MGF1 hash for the in-binary RSA handshake.
-   * - `'sha1'` (default) — matches the legacy Java backend default. Most
-   *   E2EE environments are happy with this.
-   * - `'sha256'` — sends the
-   *   `X-RSA-Encryption-Scheme: RSA/NONE/OAEPWITHSHA-256ANDMGF1PADDING`
-   *   header on every encrypted request so the server matches. Only use this
-   *   if the environment has been configured to honor the explicit header.
-   *
-   * Locked at the first `setup()` call. To change it, call `reset()` and
-   * re-`setup()` from scratch.
-   */
-  mgf1?: 'sha1' | 'sha256';
-};
-/**
- * Configuration options for the SDK setup.
- */
-type SetupOptions = {
-  /** The base URL for the API. When omitted, no HTTP client is created — useful when all API actors are overridden via .provide(). */
-  apiURL?: string;
-  /**
-   * The session token for API requests.
-   *
-   * Optional convenience — when provided, `setup` delegates to
-   * `initializeSession({ token, hostingApp })` after the HTTP client is in
-   * place. Equivalent to calling `initializeSession` yourself after
-   * `setup({ apiURL })` returns, which is the preferred shape when you want to
-   * own the moment the session is activated (e.g. between `createSession` and
-   * mounting `<incode-flow>`).
-   */
-  token?: string;
-  /** Custom headers to include in all requests */
-  customHeaders?: Record<string, string>;
-  /** Request timeout in milliseconds */
-  timeout?: number;
-  /**
-   * WASM warmup config.
-   * - Omit (default): does not load WASM.
-   * - `false`: explicitly disable WASM loading.
-   * - Object: load WASM with CDN defaults plus any overrides you provide.
-   */
-  wasm?: WasmConfig | false;
-  /**
-   * Enable end-to-end encryption for SDK traffic. When enabled, the SDK
-   * negotiates an encrypted transport during initialization (RSA-OAEP key
-   * transport + AES-GCM payload encryption). Independent of `token` —
-   * encryption can be set up before a session token is known.
-   *
-   * **Not a self-serve flag.** E2EE has to be provisioned for your account
-   * by Incode, and you'll be given a dedicated `apiURL` (typically a
-   * `*-e2ee-api.incodesmile.com` host) plus the `mgf1` scheme that
-   * environment expects. Pointing this at a non-E2EE host will fail the
-   * handshake at `setup()`. Coordinate with your Incode account team before
-   * flipping this on.
-   *
-   * Accepts:
-   * - `true` → enabled with the default OAEP MGF1 hash (`'sha1'`).
-   * - `false` (or omitted) → disabled.
-   * - `{}` → same as `true`.
-   * - `{ mgf1: 'sha256' }` → enabled with the SHA-256 MGF1 hash.
-   *
-   * Encryption requires the binary (WASM) transport. If `wasm: false` is set,
-   * `setup` throws. If `wasm` is omitted, the binary transport is provisioned
-   * automatically with CDN defaults.
-   *
-   * **Locked at boot.** The first `setup()` call decides whether encryption
-   * is on, and if so which MGF1 scheme is used. Subsequent `setup()` calls
-   * that would change either of those values throw with a descriptive error.
-   * Call `reset()` if you need to change them.
-   *
-   * **Failure modes.** `setup()` rejects with a descriptive error if the
-   * encrypted-transport handshake (`GET /e2ee/key/v2` + `POST /e2ee/key`)
-   * cannot complete — most commonly because `apiURL` points at a host that
-   * isn't provisioned for E2EE, or because the requested `mgf1` doesn't
-   * match what the environment expects. There is no built-in retry; catch
-   * and re-call `setup()` after `reset()` if your environment is
-   * known-flaky.
-   *
-   * @throws If `wasm: false` is also set, or if the handshake fails, or if
-   *   the encryption value differs from what was locked in on the first
-   *   `setup()` call.
-   */
-  encryption?: boolean | EncryptionOptions;
-  /** Optional hosting app identifier for fingerprint tracking */
-  hostingApp?: string;
-};
-/**
- * Initializes the SDK with the provided configuration.
- * Must be called before using any SDK functionality.
- *
- * WASM loads only when `options.wasm` is provided as an object.
- *
- * `setup` is boot — it provisions the HTTP client, the optional E2EE
- * handshake, WASM warmup, and the analytics batcher. The session token is a
- * separate concern: hand it off via `initializeSession({ token })` from
- * `@incodetech/core/session`, or pass it inline as `setup({ apiURL, token })`
- * (a convenience that delegates to `initializeSession` for you).
- *
- * @param options - Configuration options for the SDK
- *
- * @example Boot first, activate the session later (preferred)
- * ```ts
- * import { setup } from '@incodetech/core';
- * import { createSession, initializeSession } from '@incodetech/core/session';
- *
- * await setup({ apiURL: 'https://api.incode.com' });
- * const session = await createSession(apiKey, { configurationId });
- * await initializeSession({ token: session.token });
- * ```
- *
- * @example One-shot convenience
- * ```ts
- * await setup({ apiURL: 'https://api.incode.com', token: 'session-token' });
- * ```
- *
- * @example Explicitly disable WASM
- * ```ts
- * await setup({ apiURL: 'https://api.incode.com', wasm: false });
- * ```
- *
- * @example Use CDN defaults for paths and preload only one pipeline
- * ```ts
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   wasm: { pipelines: ['selfie'] },
- * });
- * ```
- *
- * @example Self-hosted / custom version (full or partial path overrides)
- * ```ts
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   wasm: {
- *     wasmPath: '/my-cdn/webLib.wasm',
- *     glueCodePath: '/my-cdn/webLib.js',
- *   },
- * });
- * ```
- *
- * @example Partial override: only models path, rest from CDN
- * ```ts
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   wasm: { modelsBasePath: 'https://my-cdn/models' },
- * });
- * ```
- *
- * @example Sessionless setup (all API actors overridden via .provide())
- * ```ts
- * await setup({
- *   wasm: {
- *     wasmPath: '/wasm/ml-wasm.wasm',
- *     glueCodePath: '/wasm/ml-wasm.js',
- *     pipelines: ['selfie'],
- *   },
- * });
- * ```
- *
- * @example Enable end-to-end encryption at boot (defaults to MGF1 = SHA-1)
- * ```ts
- * await setup({ apiURL: 'https://api.incode.com', encryption: true });
- * ```
- *
- * @example Enable encryption with the SHA-256 MGF1 padding
- * ```ts
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   encryption: { mgf1: 'sha256' },
- * });
- * ```
- */
-declare function setup(options: SetupOptions): Promise<void>;
-/**
- * Sets the WASM configuration without performing warmup.
- * Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
- *
- * @param config - WASM configuration to store
- */
-declare function setWasmConfig(config: WasmConfig): void;
-/**
- * Initializes WasmUtilProvider with the stored WASM configuration.
- * Should be called after warmupWasm() completes when using conditional warmup.
- * This ensures image encryption works properly.
- *
- * @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
- * @throws Error if no config is provided and none is stored
- */
-declare function initializeWasmUtil(config?: WasmConfig): Promise<void>;
-/**
- * Replaces the active HTTP client with the WASM-backed one. Used internally
- * by lazy-loading UI components (`<incode-flow>`, `<incode-workflow>`) when
- * WASM finishes warming up.
- *
- * No-op when no apiURL was originally configured, or when the active client is
- * already the WASM one.
- *
- * @internal NOT a public API. Application code should use
- *   `setup({ wasm: {...} })` instead — that path is the supported way to opt
- *   into the WASM HTTP client.
- *
- * @param config - Optional WASM configuration. Defaults to the config stored via `setWasmConfig`.
- */
-declare function upgradeToWasmHttpClient(config?: WasmConfig): Promise<void>;
-/**
- * Checks if the SDK has been configured.
- *
- * @returns true if setup() has been called, false otherwise
- */
-declare function isConfigured(): boolean;
-/**
- * Resets the SDK configuration. Useful for testing.
- */
-declare function reset(): void;
-//#endregion
-export { reset as a, upgradeToWasmHttpClient as c, isConfigured as i, WasmConfig as n, setWasmConfig as o, initializeWasmUtil as r, setup as s, SetupOptions as t };

package/dist/signature.d.ts

@@ -1,94 +0,0 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.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 };

package/dist/signature.esm.js

@@ -1,66 +0,0 @@
-import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as signatureMachine } from "./signatureStateMachine-B5-QVUve.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
-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)
-	});
-}
-
-//#endregion
-export { createSignatureManager, signatureMachine };

package/dist/signatureStateMachine-B5-QVUve.esm.js

@@ -1,132 +0,0 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { h as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-
-//#region src/modules/signature/signatureServices.ts
-/**
-* Uploads a signature image to the Omni API.
-* Uses JSON + base64 when `sendBase64` is true, otherwise sends raw JPEG bytes.
-* Throws on failure.
-*/
-async function addSignature(params, signal) {
-	const { image, type, sendBase64 = false } = params;
-	const url = sendBase64 ? endpoints.addSignatureV2 : endpoints.addSignature;
-	const body = sendBase64 ? { base64Image: image } : image;
-	const res = await api.post(url, body, {
-		signal,
-		headers: { "Content-Type": sendBase64 ? "application/json" : "image/jpeg" },
-		query: { type }
-	});
-	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() {
-	return {
-		image: void 0,
-		isValid: false,
-		error: void 0,
-		signatureSubmitResult: void 0
-	};
-}
-const signatureMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: { submitSignature: fromPromise(async ({ input, signal }) => {
-		const { ...params } = input;
-		return addSignature(params, signal);
-	}) },
-	actions: {
-		setSignatureValidity: assign(({ event }) => {
-			return {
-				isValid: event.isValid,
-				error: void 0
-			};
-		}),
-		assignImageForSubmit: assign(({ event }) => {
-			return {
-				image: event.image,
-				error: void 0
-			};
-		}),
-		setSignatureSubmitResult: assign(({ event }) => ({
-			signatureSubmitResult: event.output,
-			error: void 0
-		})),
-		setErrorFromInvoke: assign(({ event }) => {
-			const error = event.error;
-			return { error: error instanceof Error ? error.message : typeof error === "string" ? error : "Something went wrong" };
-		}),
-		clearError: assign({ error: () => void 0 }),
-		resetContext: assign({
-			isValid: () => false,
-			image: () => void 0,
-			error: () => void 0
-		}),
-		trackSubmitAttempt: () => {
-			addEvent({
-				code: "continue",
-				module: eventModuleNames.signature,
-				screen: eventScreenNames.signatureInput
-			});
-		},
-		trackError: ({ context }) => {
-			addEvent({
-				code: "verificationError",
-				module: eventModuleNames.signature,
-				payload: context.error ? { error: context.error } : void 0
-			});
-		}
-	},
-	guards: { canContinue: ({ context, event }) => context.isValid && event.type === "CONTINUE" && !!event.image }
-}).createMachine({
-	id: "signature",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		...emptyCaptureState()
-	}),
-	states: {
-		idle: { on: { LOAD: "captureSignature" } },
-		captureSignature: { on: {
-			SIGNATURE_CHANGED: { actions: "setSignatureValidity" },
-			CONTINUE: {
-				target: "submittingSignature",
-				guard: "canContinue",
-				actions: "assignImageForSubmit"
-			}
-		} },
-		submittingSignature: {
-			entry: "trackSubmitAttempt",
-			invoke: {
-				id: "submitSignature",
-				src: "submitSignature",
-				input: ({ context }) => ({
-					image: context.image,
-					type: context.config.type,
-					sendBase64: context.config.sendBase64 ?? false
-				}),
-				onDone: {
-					target: "success",
-					actions: "setSignatureSubmitResult"
-				},
-				onError: {
-					target: "error",
-					actions: "setErrorFromInvoke"
-				}
-			}
-		},
-		success: { after: { 3e3: "finished" } },
-		finished: { type: "final" },
-		error: { entry: "trackError" }
-	}
-});
-
-//#endregion
-export { signatureMachine as t };

package/dist/stats-CIfiPzb1.esm.js

@@ -1,16 +0,0 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-
-//#region src/modules/stats/statsServices.ts
-/**
-* Sends device stats to the backend.
-*/
-async function addDeviceStats(stats) {
-	try {
-		await api.post("/omni/device/stats", stats);
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-export { addDeviceStats as t };

package/dist/stats.d.ts

@@ -1,16 +0,0 @@
-//#region src/modules/stats/statsServices.d.ts
-type LabelInspectionStatus = 'FAIL' | 'PASS';
-type DeviceStats = {
-  cameraLabelInspectionStatus?: LabelInspectionStatus;
-  virtualCameraDetected?: boolean;
-  frontIdStatsAnalysisStatus?: string;
-  backIdStatsAnalysisStatus?: string;
-  selfieStatsAnalysisStatus?: string;
-  motionStatus?: string;
-};
-/**
- * Sends device stats to the backend.
- */
-declare function addDeviceStats(stats: DeviceStats): Promise<void>;
-//#endregion
-export { type DeviceStats, type LabelInspectionStatus, addDeviceStats };

package/dist/stats.esm.js

@@ -1,4 +0,0 @@
-import "./api-CESGtpbH.esm.js";
-import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
-
-export { addDeviceStats };

package/dist/trust-graph.d.ts

@@ -1,54 +0,0 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-
-//#region src/modules/trust-graph/trustGraphManager.d.ts
-type TrustGraphIdleState = {
-  status: 'idle';
-};
-type TrustGraphFinishedState = {
-  status: 'finished';
-};
-/**
- * Union of all possible trust-graph manager states.
- *
- * @example
- * ```typescript
- * const state = trustGraphManager.getState();
- * if (state.status === 'finished') {
- *   console.log('Trust graph check complete');
- * }
- * ```
- */
-type TrustGraphState = TrustGraphIdleState | TrustGraphFinishedState;
-/**
- * Creates a trust-graph manager for headless usage.
- *
- * @example Headless usage
- * ```typescript
- * const manager = createTrustGraphManager();
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * ```
- */
-declare function createTrustGraphManager(): Manager<TrustGraphState> & {
-  /**
-   * Kicks off the trust-graph module.
-   * Transitions immediately from 'idle' to 'finished' (backend-only, no SDK action).
-   */
-  load(): void;
-};
-type TrustGraphManager = ReturnType<typeof createTrustGraphManager>;
-//#endregion
-//#region src/modules/trust-graph/trustGraphStateMachine.d.ts
-declare const trustGraphMachine: any;
-//#endregion
-//#region src/modules/trust-graph/types.d.ts
-/**
- * Configuration options for the trust-graph module.
- *
- * The trust-graph module requires no configuration — it is a backend-only
- * process that runs risk scoring analysis server-side. The SDK skips
- * immediately without any user interaction.
- */
-type TrustGraphConfig = Record<string, never>;
-//#endregion
-export { type TrustGraphConfig, type TrustGraphFinishedState, type TrustGraphManager, type TrustGraphState, createTrustGraphManager, trustGraphMachine };

package/dist/trust-graph.esm.js

@@ -1,56 +0,0 @@
-import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { c as createManager, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-
-//#region src/modules/trust-graph/trustGraphStateMachine.ts
-const trustGraphMachine = setup({ types: {
-	context: {},
-	events: {}
-} }).createMachine({
-	id: "trust-graph",
-	initial: "idle",
-	context: {},
-	states: {
-		idle: { on: { LOAD: { target: "finished" } } },
-		finished: { type: "final" }
-	}
-});
-
-//#endregion
-//#region src/modules/trust-graph/trustGraphActor.ts
-function createTrustGraphActor() {
-	return createActor(trustGraphMachine).start();
-}
-
-//#endregion
-//#region src/modules/trust-graph/trustGraphManager.ts
-function mapState(snapshot) {
-	if (snapshot.matches("finished")) return { status: "finished" };
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return { load() {
-		actor.send({ type: "LOAD" });
-	} };
-}
-/**
-* Creates a trust-graph manager for headless usage.
-*
-* @example Headless usage
-* ```typescript
-* const manager = createTrustGraphManager();
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* ```
-*/
-function createTrustGraphManager() {
-	return createManager({
-		actor: createTrustGraphActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.trustGraph)
-	});
-}
-
-//#endregion
-export { createTrustGraphManager, trustGraphMachine };