@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.2

package/dist/{setup-CUO4mErT.esm.js → setup-C7tintPc.esm.js}

@@ -1,10 +1,11 @@
-import { a as WasmWebClientError, c as setWebApiHttpTransport, f as deriveSiblingJsPath, l as setupWasmConnection, o as executeWasmRequest, r as warmupWasm, s as initializeWasmWebClient, t as WasmUtilProvider } from "./WasmUtilProvider-BKWm8rSA.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { a as resetApi, i as isApiConfigured, n as getApi, o as setClient, r as getToken, t as api } from "./api-CESGtpbH.esm.js";
-import { _ as resetAnalyticsBatcher, g as getAnalyticsBatcher, m as createAnalyticsBatchingService, v as setAnalyticsBatcher } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
-import { a as setClientIpLookupEnabled, i as resetSessionInit, r as initializeSession } from "./sessionInitializer-DRB-hgbV.esm.js";
+import { a as WasmWebClientError, c as setWebApiHttpTransport, f as deriveSiblingJsPath, l as setupWasmConnection, o as executeWasmRequest, r as warmupWasm, s as initializeWasmWebClient, t as WasmUtilProvider } from "./WasmUtilProvider-CIu373BZ.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BVgutW_b.esm.js";
+import { a as resetApi, i as isApiConfigured, n as getApi, o as setClient, r as getToken, t as api } from "./api-DUZwyz0o.esm.js";
+import { _ as getAnalyticsBatcher, h as createAnalyticsBatchingService, v as resetAnalyticsBatcher, y as setAnalyticsBatcher } from "./events-DN-u67gb.esm.js";
+import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
+import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-DntyIiGr.esm.js";
+import { a as setClientIpLookupEnabled, i as resetSessionInit, r as initializeSession } from "./sessionInitializer-CaiGA8GP.esm.js";
+import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-CtxWthxz.esm.js";
 
 //#region ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
@@ -922,6 +923,29 @@ let configured = false;
 *   devMode: true, // skip the devtools detector (don't ship this in prod)
 * });
 * ```
+* @example Enable TRI — exchange the API key for an SDK token first, then pass it to setup
+* ```ts
+* const session = await createTRISession(process.env.INCODE_API_KEY, {
+*   apiURL: process.env.INCODE_TRI_API_URL,
+* });
+*
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   tri: { token: session.token, apiURL: process.env.INCODE_TRI_API_URL },
+* });
+* ```
+*
+* @example Defer TRI collection until after a consent gate
+* ```ts
+* // Boot without starting collectors:
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   tri: { token: session.token, apiURL: process.env.INCODE_TRI_API_URL, autostart: false },
+* });
+*
+* // somewhere else in the code
+* await startTRI();
+* ```
 */
 async function setup(options) {
 	if (options.ipLookup !== void 0) setClientIpLookupEnabled(options.ipLookup);
@@ -963,6 +987,7 @@ async function setup(options) {
 		await provider.setProductionMode(!showWasmLogs);
 		if (!options.devMode) startDevtoolsDetector();
 	}
+	if (options.tri) await initializeTRI(options.tri, { sessionToken: options.token });
 }
 /**
 * Sets the WASM configuration without performing warmup.
@@ -1028,9 +1053,11 @@ function reset() {
 	setClientIpLookupEnabled(true);
 	resetAnalyticsBatcher();
 	resetHttpClientState();
+	resetTRI();
 	configured = false;
 	wasmConfig = void 0;
 	WasmUtilProvider.resetInstance();
+	resetTRIProviderInstance();
 }
 
 //#endregion

package/dist/signature.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
+import { t as Manager } from "./Manager-B2OEDYqf.js";
+import "./Actor-fIPLXfoi.js";
 
 //#region src/modules/signature/types.d.ts
 /**
@@ -59,6 +59,7 @@ type CreateSignatureActorOptions = {
 };
 //#endregion
 //#region src/modules/signature/signatureManager.d.ts
+
 type SignatureIdleState = {
   status: 'idle';
 };

package/dist/signature.esm.js

@@ -1,8 +1,8 @@
-import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import { t as signatureMachine } from "./signatureStateMachine-C5qqYLRz.esm.js";
+import "./api-DUZwyz0o.esm.js";
+import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-DN-u67gb.esm.js";
+import "./endpoints-BM2_j_IE.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-Dkm1jy5u.esm.js";
+import { t as signatureMachine } from "./signatureStateMachine-DAxXmMrk.esm.js";
 
 //#region src/modules/signature/signatureActor.ts
 function createSignatureActor(options) {
@@ -11,6 +11,48 @@ function createSignatureActor(options) {
 
 //#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;
@@ -58,7 +100,7 @@ function createSignatureManager(options) {
 		actor: createSignatureActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.signature)
+		instrumentation: createManagerInstrumentation(eventModuleNames.signature, { getEventScreenName: getSignatureScreenName })
 	});
 }
 

package/dist/{signatureStateMachine-C5qqYLRz.esm.js → signatureStateMachine-DAxXmMrk.esm.js}

@@ -1,7 +1,6 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { h as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as api } from "./api-DUZwyz0o.esm.js";
+import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Dkm1jy5u.esm.js";
 
 //#region src/modules/signature/signatureServices.ts
 /**
@@ -68,21 +67,7 @@ const signatureMachine = setup({
 			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({
@@ -102,29 +87,26 @@ const signatureMachine = setup({
 				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"
-				}
+		submittingSignature: { 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" }
+		error: {}
 	}
 });
 

package/dist/{stats-BMNUG1AU.esm.js → stats-DntyIiGr.esm.js}

@@ -1,5 +1,5 @@
-import { r as getToken, t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { r as getToken, t as api } from "./api-DUZwyz0o.esm.js";
+import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
 
 //#region src/modules/stats/statsServices.ts
 const deviceStatsQueue = [];

package/dist/stats.esm.js

@@ -1,5 +1,5 @@
-import "./api-CESGtpbH.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
+import "./api-DUZwyz0o.esm.js";
+import "./endpoints-BM2_j_IE.esm.js";
+import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-DntyIiGr.esm.js";
 
 export { addDeviceStats, flushDeviceStatsQueue, resetDeviceStatsQueue };

package/dist/tri-CtxWthxz.esm.js

@@ -0,0 +1,389 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BVgutW_b.esm.js";
+
+//#region ../infra/src/providers/browser/BrowserLazyImportProvider.ts
+/**
+* Per-module {@link LazyImport} handle.
+*
+* Encapsulates the caching, deduplication, and optional-timeout logic for a
+* single lazily-imported module:
+*  - Caches the resolved module (via a dedicated `loaded` flag, so a module
+*    that legitimately resolves `undefined` is still cached) and returns it
+*    immediately on subsequent calls.
+*  - Deduplicates concurrent `load()` calls behind a single in-flight promise.
+*  - Optionally races the dynamic import against a configurable timeout (ms).
+*  - On timeout or import error: emits a `console.warn`, clears the in-flight
+*    promise so the next `load()` call retries, and resolves `undefined`.
+*
+* An attempt-generation token (`attempt`) guards against a stale import
+* mutating state after it has been superseded: when a load times out (or the
+* handle is `reset()`), the token is bumped so the still-pending import can no
+* longer write to `cachedValue` / `loaded`.
+*/
+var LazyImportHandle = class {
+	constructor(_loader, _options, _timer) {
+		this._loader = _loader;
+		this._options = _options;
+		this._timer = _timer;
+		this._loaded = false;
+		this._attempt = 0;
+	}
+	get() {
+		return this._cachedValue;
+	}
+	load() {
+		if (this._loaded) return Promise.resolve(this._cachedValue);
+		if (!this._inFlight) this._inFlight = this.startLoad();
+		return this._inFlight;
+	}
+	reset() {
+		this._cachedValue = void 0;
+		this._loaded = false;
+		this._inFlight = void 0;
+		this._attempt++;
+	}
+	startLoad() {
+		const attempt = ++this._attempt;
+		const { timeoutMs } = this._options;
+		let loaderResult;
+		try {
+			loaderResult = this._loader();
+		} catch (err) {
+			loaderResult = Promise.reject(err);
+		}
+		const loadPromise = loaderResult.then((value) => {
+			if (attempt === this._attempt) {
+				this._cachedValue = value;
+				this._loaded = true;
+			}
+			return value;
+		}, (err) => {
+			if (attempt === this._attempt) {
+				this.warnFailure(err);
+				this._inFlight = void 0;
+			}
+		});
+		if (timeoutMs === void 0) return loadPromise;
+		let timeoutHandle;
+		const timeoutPromise = new Promise((resolve) => {
+			timeoutHandle = this._timer.setTimeout(() => {
+				if (attempt === this._attempt) {
+					this.warnTimeout(timeoutMs);
+					this._inFlight = void 0;
+					this._attempt++;
+				}
+				resolve(void 0);
+			}, timeoutMs);
+		});
+		return Promise.race([loadPromise, timeoutPromise]).finally(() => {
+			if (timeoutHandle !== void 0) this._timer.clearTimeout(timeoutHandle);
+		});
+	}
+	warnFailure(err) {
+		const { label, moduleName } = this._options;
+		console.warn(`[${label}] Failed to load ${moduleName}; ${this.fallback()}`, err);
+	}
+	warnTimeout(timeoutMs) {
+		const { label, moduleName } = this._options;
+		console.warn(`[${label}] ${moduleName} failed to load within ${timeoutMs / 1e3}s; ${this.fallback()}`);
+	}
+	fallback() {
+		return this._options.disabledMessage ?? "module will be unavailable.";
+	}
+};
+/**
+* Concrete implementation of {@link ILazyImportCapability}.
+*
+* `create()` returns a per-module {@link LazyImportHandle}. The
+* {@link ITimerCapability} is injected so tests can replace the real
+* `setTimeout`/`clearTimeout` with a controllable fake.
+*/
+var BrowserLazyImportProvider = class BrowserLazyImportProvider {
+	constructor(timer) {
+		this._timer = timer ?? BrowserTimerProvider.getInstance();
+	}
+	static getInstance() {
+		return this._instance ??= new BrowserLazyImportProvider();
+	}
+	static resetInstance() {
+		this._instance = void 0;
+	}
+	create(loader, options) {
+		return new LazyImportHandle(loader, options, this._timer);
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/TransactionalRiskIntelligenceProvider.ts
+const LAZY_IMPORT_OPTIONS = {
+	label: "TRI",
+	moduleName: "@incodetech/tri-sdk",
+	timeoutMs: 1e4,
+	disabledMessage: "TRI will be disabled for this session."
+};
+const importSdk = () => import("./tri.esm-CrWAulDi.esm.js");
+/**
+* Concrete implementation of {@link ITransactionalRiskIntelligenceCapability}.
+*
+* This is the **only** file in the repo that references `@incodetech/tri-sdk`.
+* The third-party module is loaded via a dynamic `import()` the first time
+* {@link setup} is called, so consumers that never opt into TRI (i.e. never
+* pass `tri` to `setup()`) do not pay the bundle cost.
+*
+* `start()`, `stop()`, `reset()`, and `linkInterview()` require a prior
+* successful `setup()` call. The SDK cannot start without the foundation,
+* collection-status check, and managers that `setup()` establishes. Calling
+* these methods before `setup()` is a no-op that returns `'init-failed'` or
+* `false` respectively.
+*
+* The dynamic `import('@incodetech/tri-sdk')` is managed by
+* {@link BrowserLazyImportProvider}, which races the import against a
+* {@link LOAD_TIMEOUT_MS}-ms timeout. On timeout the provider warns, clears
+* the cached promise (so a subsequent `setup()` can retry), and resolves
+* `undefined`, gracefully disabling TRI for the session.
+*/
+var TransactionalRiskIntelligenceProvider = class TransactionalRiskIntelligenceProvider {
+	constructor() {
+		this._isStarted = false;
+		this._lazySdk = BrowserLazyImportProvider.getInstance().create(importSdk, LAZY_IMPORT_OPTIONS);
+	}
+	static getInstance() {
+		return this._instance ??= new TransactionalRiskIntelligenceProvider();
+	}
+	static resetInstance() {
+		this._instance = void 0;
+	}
+	get isStarted() {
+		return this._isStarted;
+	}
+	/**
+	* Lazy-loads `@incodetech/tri-sdk` (shared lazy handle) and exchanges the
+	* organization API key for a short-lived SDK token via the module's
+	* `createSession`. On a load timeout/failure returns an error-shaped session
+	* rather than throwing, so the boot path is never blocked.
+	*/
+	async createSession(apiKey, options) {
+		const module = await this._lazySdk.load();
+		if (!module) return {
+			token: null,
+			expiresAt: null,
+			tokenType: null,
+			eventsCollectionEnabled: false,
+			error: {
+				status: 0,
+				message: "TRI SDK failed to load"
+			}
+		};
+		return module.createSession(apiKey, options);
+	}
+	/**
+	* Lazy-loads `@incodetech/tri-sdk` on first call (with a {@link LOAD_TIMEOUT_MS}-ms
+	* timeout), then delegates to its `setup()`. Returns a promise that resolves
+	* once the SDK module has been fetched and the backend collection-status
+	* check has completed.
+	*
+	* When `config.autostart` is `true` (the default), the underlying `setup()`
+	* also calls `start()` and returns `'started'` on success. `_isStarted` is
+	* updated to reflect the resulting state so that `isTRIStarted()` is
+	* accurate immediately after `setup()` returns.
+	*/
+	async setup(config) {
+		try {
+			const module = await this._lazySdk.load();
+			if (!module) return "init-failed";
+			const state = await module.default.setup(config);
+			if (state === "started") this._isStarted = true;
+			return state;
+		} catch {
+			return "init-failed";
+		}
+	}
+	/**
+	* Begins behavioral data collection. Requires a prior successful `setup()`.
+	* Returns `'init-failed'` without starting if called before `setup()`.
+	*/
+	async start() {
+		const state = await (this._getSdk()?.start() ?? Promise.resolve("init-failed"));
+		this._isStarted = state === "started";
+		return state;
+	}
+	/**
+	* Stops all collectors and managers. No-op when called before `setup()`.
+	*/
+	async stop() {
+		const state = await (this._getSdk()?.stop() ?? Promise.resolve("init-failed"));
+		this._isStarted = false;
+		return state;
+	}
+	/**
+	* Resets the TRI SDK to its initial state. No-op when called before `setup()`.
+	*/
+	async reset() {
+		const state = await (this._getSdk()?.reset() ?? Promise.resolve("init-failed"));
+		this._isStarted = false;
+		return state;
+	}
+	/**
+	* Links an interview to the current TRI activity. Returns `false` when
+	* called before `setup()` or when the backend request fails. Never throws,
+	* so the boot/flow path is never blocked by a failed link.
+	*
+	* @param sessionToken - The Incode session token to link.
+	*/
+	async linkInterview(sessionToken) {
+		try {
+			return await this._getSdk()?.linkInterview(sessionToken) ?? false;
+		} catch {
+			return false;
+		}
+	}
+	_getSdk() {
+		return this._lazySdk.get()?.default ?? null;
+	}
+};
+
+//#endregion
+//#region src/integrations/tri/tri.ts
+/**
+* Returns the active TRI capability implementation.
+*
+* Core functions depend on {@link ITransactionalRiskIntelligenceCapability}
+* (the interface) rather than the concrete provider class. The provider is
+* referenced here only to supply the default singleton. This integration
+* module is the single owner of the concrete provider reference — the rest of
+* core goes through these functions ({@link isTRIStarted},
+* {@link resetTRIProviderInstance}, etc.) instead of importing the provider.
+*/
+function getProvider() {
+	return TransactionalRiskIntelligenceProvider.getInstance();
+}
+/**
+* Returns `true` when TRI collectors are currently running (a successful
+* `setupTRI()` autostart or explicit `startTRI()`, with no subsequent
+* `stopTRI()`/`resetTRI()`). Returns `false` before setup or after teardown.
+*/
+function isTRIStarted() {
+	return getProvider().isStarted;
+}
+/**
+* Discards the cached TRI provider singleton so the next access constructs a
+* fresh instance. Call from the SDK's `reset()` after `resetTRI()` to clear
+* the `isStarted` flag and lazy-import state.
+*/
+function resetTRIProviderInstance() {
+	TransactionalRiskIntelligenceProvider.resetInstance();
+}
+/**
+* Exchanges an organization API key for a short-lived TRI SDK token. This is
+* the entry point that triggers the lazy-load of `@incodetech/tri-sdk` (via the
+* provider's dynamic `import()`); the cached lazy handle is reused by a
+* subsequent `setupTRI()`.
+*
+* In production the exchange should happen server-side. On a load timeout or
+* failure the returned session carries `token: null` and an `error`, rather
+* than throwing.
+*
+* @param apiKey  - Organization API key.
+* @param options - Optional `apiURL`, `signal`, and `timeout` overrides.
+*/
+async function createTRISession(apiKey, options) {
+	return getProvider().createSession(apiKey, options);
+}
+/**
+* Initializes TRI in a single step: resolves the config, calls `setupTRI`
+* (which autostarts unless `config.autostart` is `false`), and optionally
+* links the current Incode session.
+*
+* Returns the resolved {@link TransactionalRiskIntelligenceState}. If the
+* config cannot be resolved (e.g. missing `token` or `apiURL`), returns
+* `'init-failed'` after emitting a `[TRI]` warning.
+*
+* When `config.autostart` is `false`, the underlying `setupTRI` returns
+* `'ready'` without starting collection — call `startTRI()` explicitly when
+* ready (e.g. after a consent gate). Linking is skipped in that case since
+* TRI has not started.
+*
+* @param config  - TRI setup config (must include `token` and `apiURL`).
+* @param options - Optional session-linking hints (`sessionToken`).
+*/
+async function initializeTRI(config, options = {}) {
+	const resolvedTriConfig = resolveTRIConfig(config);
+	if (!resolvedTriConfig) return "init-failed";
+	const state = await setupTRI(resolvedTriConfig);
+	if (isTRIStarted() && options.sessionToken) await linkSessionWithTRI(options.sessionToken);
+	return state;
+}
+/**
+* Calls the provider's `setup()` with the given config. This is the step that
+* lazy-loads `@incodetech/tri-sdk`, validates the config, and checks the
+* backend collection-status endpoint. When `config.autostart` is `true` (the
+* default), also calls `start()` internally and returns `'started'` on
+* success. Pass `autostart: false` to receive `'ready'` and start explicitly.
+*
+* @param config - Resolved TRI config (`token` and `apiURL` required).
+* @returns The resulting {@link TransactionalRiskIntelligenceState}.
+*/
+async function setupTRI(config) {
+	return getProvider().setup(config);
+}
+/**
+* Begins behavioral data collection. Requires a prior successful `setupTRI()`
+* call with `autostart: false`. Returns `'init-failed'` without starting if
+* called before setup, or is a no-op if already started.
+*
+* @returns The resulting {@link TransactionalRiskIntelligenceState}.
+*/
+async function startTRI() {
+	return getProvider().start();
+}
+/**
+* Stops all TRI collectors and managers. Idempotent. No-op if TRI was never
+* set up.
+*/
+async function stopTRI() {
+	return getProvider().stop();
+}
+/**
+* Resets the TRI SDK to its initial state. Call this from the SDK's `reset()`
+* so that a subsequent `setupTRI` / `startTRI` can begin fresh.
+*/
+async function resetTRI() {
+	return getProvider().reset();
+}
+/**
+* Links the current Incode interview session to the active TRI activity.
+*
+* Returns `false` when the session token is missing or TRI has not been set up.
+*
+* @param sessionToken - Incode session JWT.
+*/
+async function linkSessionWithTRI(sessionToken) {
+	if (!sessionToken) return false;
+	return getProvider().linkInterview(sessionToken);
+}
+/**
+* @private This function is not used outside of this file.
+*
+* Validates and narrows a {@link TransactionalRiskIntelligenceSetupConfig}
+* into a {@link TransactionalRiskIntelligenceConfig} suitable for passing to
+* the provider's `setup()`.
+*
+* Returns `null` (with a `[TRI]` warning) when a required field is missing.
+* Returns `null` silently when `config` is `undefined` (intentional opt-out).
+*
+* @param config - Raw setup-time config from `SetupOptions.tri`.
+*/
+function resolveTRIConfig(config) {
+	if (!config) return null;
+	if (!config.token) {
+		console.warn("[TRI] Not initialized: token is required.");
+		return null;
+	}
+	if (!config.apiURL) {
+		console.warn("[TRI] Not initialized: apiURL is required.");
+		return null;
+	}
+	return config;
+}
+
+//#endregion
+export { resetTRI as a, startTRI as c, linkSessionWithTRI as i, stopTRI as l, initializeTRI as n, resetTRIProviderInstance as o, isTRIStarted as r, setupTRI as s, createTRISession as t };

package/dist/tri.d.ts

@@ -0,0 +1,2 @@
+import { a as startTRI, i as setupTRI, n as isTRIStarted, o as stopTRI, r as resetTRI, s as TransactionalRiskIntelligenceSetupConfig, t as createTRISession } from "./index-52_qi4bd.js";
+export { TransactionalRiskIntelligenceSetupConfig, createTRISession, isTRIStarted, resetTRI, setupTRI, startTRI, stopTRI };