@incodetech/core 0.0.0-dev-20260716-2b4f5edb → 0.0.0-dev-20260717-87fac45b

package/dist/feature-management-Dw96qEMs.esm.js

@@ -0,0 +1,468 @@
+import { a as __toESM } from "./rolldown-runtime-FZ4Itg2g.esm.js";
+import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
+let currentEnvironment;
+/** Effective tier: the explicitly-set value, else the default (see note above). */
+function getEnvironment() {
+	return currentEnvironment ?? "production";
+}
+/** Clears the stored tier. Called by the SDK's `reset()`. */
+function resetEnvironment() {
+	currentEnvironment = void 0;
+}
+/**
+* Applies a requested tier from a `setup()` call and reports the transition:
+* - `'unchanged'` — omitted, same value as already stored, or first-set to
+*   the default.
+* - `'changed'` — first-set (was defaulting) to a non-default value.
+*   Informational only: no consumer reconstructs on this today. Feature
+*   management reads the tier once at its own first initialization and never
+*   rebuilds, regardless of this status.
+* - `'rejected'` — already locked to a different value; logs a
+*   `console.error` and keeps the locked value.
+*/
+function applyEnvironment(next) {
+	if (next === void 0) return "unchanged";
+	if (currentEnvironment === void 0) {
+		currentEnvironment = next;
+		return next === "production" ? "unchanged" : "changed";
+	}
+	if (next === currentEnvironment) return "unchanged";
+	console.error(`[environment] \`environment\` cannot be changed after the initial setup() call. Keeping '${currentEnvironment}'; ignoring '${next}'. Call reset() to change it.`);
+	return "rejected";
+}
+//#endregion
+//#region ../infra/src/providers/browser/FeatureManagementProvider.ts
+/**
+* A client SDK key is safe to ship in a public bundle — it only grants
+* read-only evaluation, no console/admin access.
+*
+* Note: Proper improvement would be if backend creates specialized
+* endpoint for returning these type of information, so we could have full decoupling.
+*/
+const CLIENT_SDK_KEY = "client-GBTzsiJ99rvyZQdNXDFkftx3ZoMF1TED2rsB3m3IUqc";
+const LOAD_TIMEOUT_MS = 1e4;
+const FEATURE_MANAGEMENT_REQUEST_TIMEOUT_MS = 3e3;
+const LAZY_IMPORT_OPTIONS = {
+	label: "FeatureManagement",
+	moduleName: "@statsig/js-client",
+	timeoutMs: LOAD_TIMEOUT_MS,
+	disabledMessage: "Feature gates/experiments/layers will be disabled for this session."
+};
+/**
+* Resolved default for {@link FeatureManagementConfig.redactedUserInfo}:
+* `ip` and `country` are redacted unless a caller explicitly opts out.
+*/
+const DEFAULT_REDACTED_USER_INFO = {
+	ip: true,
+	country: true
+};
+const fallbackTypedGetter = (_paramName, fallback) => fallback;
+function createFallback(status) {
+	return Object.freeze({
+		get: fallbackTypedGetter,
+		groupName: null,
+		status
+	});
+}
+/**
+* Concrete {@link IFeatureManagementCapability} backed by Statsig
+* (`@statsig/js-client`), lazy-loaded on first `initialize()` call so
+* consumers that never read a gate/experiment/layer never pay its bundle cost.
+*
+* No `apiKey` is ever passed to Statsig — identity is built up purely from
+* randomization-unit `customIDs` supplied at `initialize()`/`updateUser()`
+* time, plus the client SDK's own auto-generated StableID.
+*
+* Mirrors {@link TransactionalRiskIntelligenceProvider}: every public method
+* is graceful — a load failure, timeout, or evaluation error never throws
+* and never rejects. Reads fall back to their documented defaults and
+* mutating calls become no-ops.
+*/
+var FeatureManagementProvider = class FeatureManagementProvider {
+	constructor() {
+		this._user = {};
+		this._redactedUserInfo = { ...DEFAULT_REDACTED_USER_INFO };
+		this._lazySdk = BrowserLazyImportProvider.getInstance().create(importStatsigJsClient, LAZY_IMPORT_OPTIONS);
+	}
+	static getInstance() {
+		return this._instance ??= new FeatureManagementProvider();
+	}
+	static resetInstance() {
+		this._instance = void 0;
+	}
+	get initialized() {
+		return this._client !== void 0;
+	}
+	async initialize(config) {
+		try {
+			const module = await this._lazySdk.load();
+			if (!module) return;
+			this._redactedUserInfo = {
+				...DEFAULT_REDACTED_USER_INFO,
+				...config.redactedUserInfo
+			};
+			this._user = this._getAdjustedUser({
+				customIDs: config.customIDs,
+				custom: config.custom
+			});
+			const client = new module.StatsigClient(CLIENT_SDK_KEY, this._user, {
+				environment: { tier: config.environment },
+				disableStableID: config.disableStableId,
+				disableStorage: config.disablePersistence
+			});
+			await client.initializeAsync({ timeoutMs: FEATURE_MANAGEMENT_REQUEST_TIMEOUT_MS });
+			this._client = client;
+		} catch (error) {
+			console.warn("[FeatureManagement] initialize() failed; gates/experiments/layers will be disabled for this session.", error);
+		}
+	}
+	async updateUser(user) {
+		if (!this._client) return;
+		this._user = this._getAdjustedUser(user);
+		try {
+			await this._client.updateUserAsync(this._user, { timeoutMs: FEATURE_MANAGEMENT_REQUEST_TIMEOUT_MS });
+		} catch (error) {
+			console.warn("[FeatureManagement] updateUser() failed.", error);
+		}
+	}
+	getFeatureGate(name) {
+		if (!this._client) return {
+			enabled: false,
+			status: "uninitialized"
+		};
+		try {
+			return {
+				enabled: this._client.checkGate(name),
+				status: "initialized"
+			};
+		} catch {
+			return {
+				enabled: false,
+				status: "error"
+			};
+		}
+	}
+	getExperiment(name) {
+		if (!this._client) return createFallback("uninitialized");
+		try {
+			const experiment = this._client.getExperiment(name);
+			return {
+				get: experiment.get,
+				groupName: experiment.groupName,
+				status: "initialized"
+			};
+		} catch {
+			return createFallback("error");
+		}
+	}
+	getLayer(name) {
+		if (!this._client) return createFallback("uninitialized");
+		try {
+			const layer = this._client.getLayer(name);
+			return {
+				get: layer.get,
+				groupName: layer.groupName,
+				status: "initialized"
+			};
+		} catch {
+			return createFallback("error");
+		}
+	}
+	getParameterStore(name) {
+		if (!this._client) return createFallback("uninitialized");
+		try {
+			return {
+				get: this._client.getParameterStore(name).get,
+				status: "initialized"
+			};
+		} catch {
+			return createFallback("error");
+		}
+	}
+	getDynamicConfig(name) {
+		if (!this._client) return null;
+		try {
+			return this._client.getDynamicConfig(name).value;
+		} catch {
+			return null;
+		}
+	}
+	logEvent(name, value, options) {
+		if (!this._client) return;
+		try {
+			const metadata = options?.metadata ? stringifyEventMetadata(options.metadata) : void 0;
+			this._client.logEvent(name, value, metadata);
+			if (options?.type === "immediate") this._client.flush().catch(() => {});
+		} catch {}
+	}
+	async reset() {
+		const client = this._client;
+		this._client = void 0;
+		this._user = {};
+		this._redactedUserInfo = { ...DEFAULT_REDACTED_USER_INFO };
+		return client?.shutdown().catch(() => {});
+	}
+	_getAdjustedUser(user) {
+		const persistedUserCustomIDs = this._user.customIDs ?? {};
+		const persistedUserCustom = this._user.custom ?? {};
+		return {
+			customIDs: {
+				...persistedUserCustomIDs,
+				...user.customIDs
+			},
+			custom: {
+				...persistedUserCustom,
+				...user.custom
+			},
+			...this._getRedactedFields()
+		};
+	}
+	/** Blanks out every `StatsigUser` field flagged in {@link _redactedUserInfo}. */
+	_getRedactedFields() {
+		const fields = {};
+		for (const key in this._redactedUserInfo) if (this._redactedUserInfo[key]) fields[key] = "";
+		return fields;
+	}
+};
+/**
+* Statsig's `logEvent` only accepts string metadata values. Non-string
+* values (booleans, numbers, nested objects) are JSON-stringified so
+* callers can pass richer metadata without needing to know that constraint.
+*/
+const stringifyEventMetadata = (metadata) => {
+	const stringified = {};
+	for (const key in metadata) {
+		const value = metadata[key];
+		if (typeof value === "string") stringified[key] = value;
+		else stringified[key] = JSON.stringify(value);
+	}
+	return stringified;
+};
+const importStatsigJsClient = () => import("./src-0Jurt29N.esm.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+//#endregion
+//#region src/integrations/feature-management/featureManagement.ts
+/**
+* Returns the active FeatureManagement capability implementation.
+*
+* Core functions depend on {@link IFeatureManagementCapability} (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.
+*/
+function getProvider() {
+	return FeatureManagementProvider.getInstance();
+}
+let resolveReady;
+const freshReady = () => new Promise((resolve) => {
+	resolveReady = resolve;
+});
+let readyPromise = freshReady();
+const assignedExperiments = /* @__PURE__ */ new Set();
+let version = 0;
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Subscribes to changes in the FeatureManagement user identity (readiness
+* settling, `updateFeatureManagementUser`, or `resetFeatureManagement`).
+* Returns an unsubscribe function. Intended for UI to re-read
+* gates/experiments/layers whenever the shared identity changes, no matter
+* which caller triggered the change — see `getFeatureManagementVersion`.
+*/
+function subscribeFeatureManagement(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+/**
+* Monotonically increasing revision of the FeatureManagement user identity.
+* Pair with {@link subscribeFeatureManagement} (e.g. via
+* `useSyncExternalStore`) to force a re-read after any identity change.
+* The number itself carries no meaning beyond "has this changed since my
+* last read".
+*/
+function getFeatureManagementVersion() {
+	return version;
+}
+/**
+* Bumps {@link getFeatureManagementVersion} and notifies every
+* {@link subscribeFeatureManagement} listener. Called after readiness
+* settles, a successful `updateFeatureManagementUser`, and `resetFeatureManagement` —
+* never for no-ops, so listeners aren't notified spuriously (which would
+* cause unnecessary re-reads and, for experiments/layers, re-logged exposures).
+*/
+function notifyFeatureManagementChanged() {
+	version += 1;
+	for (const listener of listeners) listener();
+}
+let isFeatureManagementLocked = false;
+/**
+* Initializes feature management for the current (anonymous) user.
+*
+* Deliberately takes no `apiKey` — identity starts with only the client
+* SDK's auto-generated StableID plus the deployment tier from
+* `options.environment` (defaults to `'production'` when omitted), plus
+* `client_experiment_id` when supplied. Additional randomization units
+* (`hashed_onboarding_id`, `flow_id`, and `workflow_id`) are merged in later via
+* {@link updateFeatureManagementUser} as they become known during the
+* session lifecycle.
+*
+* May be called only once per SDK lifecycle. Every later call logs a
+* `console.error` and is ignored; {@link resetFeatureManagement} starts a new
+* lifecycle.
+*
+* Never throws — a failure here must never block SDK boot.
+*/
+async function initializeFeatureManagement(options = {}) {
+	if (isFeatureManagementLocked) return;
+	isFeatureManagementLocked = true;
+	try {
+		const initializeOptions = buildInitializeOptions(options);
+		await getProvider().initialize(initializeOptions);
+	} catch (error) {
+		console.warn("Feature management initialization failed:", error);
+	} finally {
+		settleFeatureManagementReady(getProvider().initialized);
+	}
+}
+/**
+* Records the opt-out decision for the current SDK lifecycle: locks feature
+* management (so no later `setup()` call can enable it) and settles
+* readiness to `false`.
+*
+* Like {@link initializeFeatureManagement}, this may only run once per SDK
+* lifecycle — call from `setup()` only when the lock is not already held.
+* {@link resetFeatureManagement} starts a new lifecycle.
+*/
+function optOutFeatureManagement() {
+	isFeatureManagementLocked = true;
+	settleFeatureManagementReady(false);
+}
+/** Settles feature-management readiness for the current SDK lifecycle. */
+function settleFeatureManagementReady(initialized) {
+	resolveReady(initialized);
+	notifyFeatureManagementChanged();
+}
+/**
+* Resolves once feature-management boot for the current SDK lifecycle has
+* settled.
+*/
+function getIsFeatureManagementInitialized() {
+	return readyPromise;
+}
+/**
+* Merges additional randomization-unit custom IDs (and, optionally,
+* analytics/targeting-only `custom` attributes) into the active
+* FeatureManagement user and re-evaluates.
+*
+* `flow_id` is populated from the flow response before `getFlow` resolves;
+* `workflow_id` is populated from the workflow configuration before
+* `loadWorkflow` resolves. `custom` lets callers enrich identity with
+* attributes discovered later in the session (e.g. a backend-driven flag)
+* without needing a randomization unit — unlike `customIDs`, `custom`
+* values never bucket experiments, only affect targeting conditions and
+* event annotation.
+*
+* `undefined` values in `customIDs` are dropped before merging — they mean
+* "not yet known", never "clear this ID". No-op when every `customIDs`
+* value is `undefined` and no `custom` is supplied, or when
+* `initializeFeatureManagement` was never called (or failed).
+*/
+async function updateFeatureManagementUser(update) {
+	const { customIDs = {}, custom } = update;
+	let hasAdaptedCustomIDs = false;
+	const adaptedCustomIDs = {};
+	for (const key in customIDs) if (customIDs[key] !== void 0) {
+		adaptedCustomIDs[key] = customIDs[key];
+		hasAdaptedCustomIDs = true;
+	}
+	if (!hasAdaptedCustomIDs && !custom) return;
+	await getProvider().updateUser({
+		customIDs: adaptedCustomIDs,
+		custom
+	});
+	notifyFeatureManagementChanged();
+}
+/** Evaluates a feature gate. Returns a fallback-only result before initialization. */
+function getFeatureGate(name) {
+	return getProvider().getFeatureGate(name);
+}
+/** Evaluates an experiment. Returns a fallback-only result before initialization. */
+function getExperiment(name) {
+	return getProvider().getExperiment(name);
+}
+/** Evaluates a layer. Returns a fallback-only result before initialization. Exposure is logged natively per-parameter on `.get()`. */
+function getLayer(name) {
+	return getProvider().getLayer(name);
+}
+/** Evaluates a parameter store. Returns a fallback-only result before initialization. Exposure is logged natively for the mapped source on `.get()`. */
+function getFeatureParameterStore(name) {
+	return getProvider().getParameterStore(name);
+}
+/** Evaluates a dynamic config. Returns `null` before initialization or if the config is unknown. */
+function getFeatureDynamicConfig(name) {
+	return getProvider().getDynamicConfig(name);
+}
+/**
+* Logs a custom analytics event to the FeatureManagement provider. No-op
+* before initialization.
+*
+* `type: 'scheduled'` (default) batches the event with the underlying
+* SDK's normal flush cadence. `type: 'immediate'` logs then flushes right
+* away — use for events that must reach the backend even if the page is
+* about to unload (e.g. a one-time experiment-assignment event).
+*/
+function logEvent(name, value, options) {
+	getProvider().logEvent(name, value, options);
+}
+/**
+* Emits an experiment-assignment event once per flag key for the current SDK
+* lifecycle. Calls before successful feature-management initialization are
+* ignored.
+*/
+function assignExperimentOnce(flagKey, payload, eventName = "experimentAssigned") {
+	if (!getProvider().initialized || assignedExperiments.has(flagKey)) return;
+	assignedExperiments.add(flagKey);
+	logEvent(eventName, void 0, {
+		metadata: {
+			...payload,
+			flagKey
+		},
+		type: "immediate"
+	});
+}
+/**
+* Tears down the active FeatureManagement client and clears the
+* initialization-attempt flag, so a
+* subsequent `setup()` call starts fresh instead of treating the SDK as
+* already booted. Call from the SDK's `reset()`. Safe no-op when never
+* initialized.
+*/
+function resetFeatureManagement() {
+	isFeatureManagementLocked = false;
+	readyPromise = freshReady();
+	assignedExperiments.clear();
+	getProvider().reset();
+	notifyFeatureManagementChanged();
+}
+/**
+* Discards the cached FeatureManagement provider singleton (including its
+* lazy-import cache) so the next access constructs a fresh instance. Call
+* from the SDK's `reset()` alongside {@link resetFeatureManagement}.
+*/
+function resetFeatureManagementProviderInstance() {
+	FeatureManagementProvider.resetInstance();
+}
+function getIsFeatureManagementLocked() {
+	return isFeatureManagementLocked;
+}
+function buildInitializeOptions(options) {
+	const initializeOptions = { environment: options.environment ?? "production" };
+	if (options.clientExperimentId) initializeOptions.customIDs = { client_experiment_id: options.clientExperimentId };
+	if (options.custom) initializeOptions.custom = options.custom;
+	if (options.redactedUserInfo) initializeOptions.redactedUserInfo = options.redactedUserInfo;
+	initializeOptions.disableStableId = options.disableStableId ?? true;
+	initializeOptions.disablePersistence = options.disablePersistence ?? true;
+	return initializeOptions;
+}
+//#endregion
+export { applyEnvironment as _, getFeatureManagementVersion as a, getIsFeatureManagementLocked as c, logEvent as d, optOutFeatureManagement as f, updateFeatureManagementUser as g, subscribeFeatureManagement as h, getFeatureGate as i, getLayer as l, resetFeatureManagementProviderInstance as m, getExperiment as n, getFeatureParameterStore as o, resetFeatureManagement as p, getFeatureDynamicConfig as r, getIsFeatureManagementInitialized as s, assignExperimentOnce as t, initializeFeatureManagement as u, getEnvironment as v, resetEnvironment as y };

package/dist/feature-management.d.ts

@@ -0,0 +1,80 @@
+import { a as FeatureManagementParameterStore, c as FeatureManagementUserUpdate, i as FeatureManagementLayer, n as FeatureManagementExperiment, o as FeatureManagementReadStatus, r as FeatureManagementGate, s as FeatureManagementRedactedUserInfo, t as FeatureManagementEventMetadata } from "./IFeatureManagementCapability-ErPJywQ_.js";
+//#region src/integrations/feature-management/featureManagement.d.ts
+/**
+ * Subscribes to changes in the FeatureManagement user identity (readiness
+ * settling, `updateFeatureManagementUser`, or `resetFeatureManagement`).
+ * Returns an unsubscribe function. Intended for UI to re-read
+ * gates/experiments/layers whenever the shared identity changes, no matter
+ * which caller triggered the change — see `getFeatureManagementVersion`.
+ */
+declare function subscribeFeatureManagement(listener: () => void): () => void;
+/**
+ * Monotonically increasing revision of the FeatureManagement user identity.
+ * Pair with {@link subscribeFeatureManagement} (e.g. via
+ * `useSyncExternalStore`) to force a re-read after any identity change.
+ * The number itself carries no meaning beyond "has this changed since my
+ * last read".
+ */
+declare function getFeatureManagementVersion(): number;
+/**
+ * Resolves once feature-management boot for the current SDK lifecycle has
+ * settled.
+ */
+declare function getIsFeatureManagementInitialized(): Promise<boolean>;
+/**
+ * Merges additional randomization-unit custom IDs (and, optionally,
+ * analytics/targeting-only `custom` attributes) into the active
+ * FeatureManagement user and re-evaluates.
+ *
+ * `flow_id` is populated from the flow response before `getFlow` resolves;
+ * `workflow_id` is populated from the workflow configuration before
+ * `loadWorkflow` resolves. `custom` lets callers enrich identity with
+ * attributes discovered later in the session (e.g. a backend-driven flag)
+ * without needing a randomization unit — unlike `customIDs`, `custom`
+ * values never bucket experiments, only affect targeting conditions and
+ * event annotation.
+ *
+ * `undefined` values in `customIDs` are dropped before merging — they mean
+ * "not yet known", never "clear this ID". No-op when every `customIDs`
+ * value is `undefined` and no `custom` is supplied, or when
+ * `initializeFeatureManagement` was never called (or failed).
+ */
+declare function updateFeatureManagementUser(update: FeatureManagementUserUpdate): Promise<void>;
+/** Evaluates a feature gate. Returns a fallback-only result before initialization. */
+declare function getFeatureGate(name: string): FeatureManagementGate;
+/** Evaluates an experiment. Returns a fallback-only result before initialization. */
+declare function getExperiment(name: string): FeatureManagementExperiment;
+/** Evaluates a layer. Returns a fallback-only result before initialization. Exposure is logged natively per-parameter on `.get()`. */
+declare function getLayer(name: string): FeatureManagementLayer;
+/** Evaluates a parameter store. Returns a fallback-only result before initialization. Exposure is logged natively for the mapped source on `.get()`. */
+declare function getFeatureParameterStore(name: string): FeatureManagementParameterStore;
+/** Evaluates a dynamic config. Returns `null` before initialization or if the config is unknown. */
+declare function getFeatureDynamicConfig(name: string): Record<string, unknown> | null;
+/**
+ * Logs a custom analytics event to the FeatureManagement provider. No-op
+ * before initialization.
+ *
+ * `type: 'scheduled'` (default) batches the event with the underlying
+ * SDK's normal flush cadence. `type: 'immediate'` logs then flushes right
+ * away — use for events that must reach the backend even if the page is
+ * about to unload (e.g. a one-time experiment-assignment event).
+ */
+declare function logEvent(name: string, value?: string | number, options?: {
+  metadata?: FeatureManagementEventMetadata;
+  type?: 'scheduled' | 'immediate';
+}): void;
+type ExperimentAssignmentPayload = {
+  experimentId: string;
+  experimentName: string;
+  module: string;
+  variant: string;
+  conditions: Record<string, boolean | number | string>;
+};
+/**
+ * Emits an experiment-assignment event once per flag key for the current SDK
+ * lifecycle. Calls before successful feature-management initialization are
+ * ignored.
+ */
+declare function assignExperimentOnce(flagKey: string, payload: ExperimentAssignmentPayload, eventName?: string): void;
+//#endregion
+export { type ExperimentAssignmentPayload, type FeatureManagementExperiment, type FeatureManagementGate, type FeatureManagementLayer, type FeatureManagementParameterStore, type FeatureManagementReadStatus, type FeatureManagementRedactedUserInfo, type FeatureManagementUserUpdate, assignExperimentOnce, getExperiment, getFeatureDynamicConfig, getFeatureGate, getFeatureManagementVersion, getFeatureParameterStore, getIsFeatureManagementInitialized, getLayer, logEvent, subscribeFeatureManagement, updateFeatureManagementUser };

package/dist/feature-management.esm.js

@@ -0,0 +1,2 @@
+import { a as getFeatureManagementVersion, d as logEvent, g as updateFeatureManagementUser, h as subscribeFeatureManagement, i as getFeatureGate, l as getLayer, n as getExperiment, o as getFeatureParameterStore, r as getFeatureDynamicConfig, s as getIsFeatureManagementInitialized, t as assignExperimentOnce } from "./feature-management-Dw96qEMs.esm.js";
+export { assignExperimentOnce, getExperiment, getFeatureDynamicConfig, getFeatureGate, getFeatureManagementVersion, getFeatureParameterStore, getIsFeatureManagementInitialized, getLayer, logEvent, subscribeFeatureManagement, updateFeatureManagementUser };

package/dist/flow.esm.js

@@ -1,7 +1,7 @@
 import { m as addEvent } from "./events-Dy8PyVO5.esm.js";
 import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-DL7qnTQR.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-ymcivfU0.esm.js";
 import { n as getFinishStatus, r as getTotalScoreStatus, t as classifyScoreStatus } from "./flowCompletionService-DQSC7Kso.esm.js";
 import { n as isAdvanceableError, r as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-Crz1nHwJ.esm.js";
 //#region src/modules/flow/noOpFlowModuleMachine.ts

package/dist/{flowServices-DL7qnTQR.esm.js → flowServices-ymcivfU0.esm.js}

@@ -1,8 +1,9 @@
+import { g as updateFeatureManagementUser } from "./feature-management-Dw96qEMs.esm.js";
 import { t as api } from "./api-BDTZNnca.esm.js";
 import { t as endpoints } from "./endpoints-DLQ0g4-R.esm.js";
-import { i as initializeSession, r as getSessionFingerprintResult } from "./sessionInitializer-B6n-FYf7.esm.js";
+import { i as initializeSession, r as getSessionFingerprintResult } from "./sessionInitializer-CrzyJ4Y0.esm.js";
 import { n as toIncodeApiError } from "./apiError-COvIGYWe.esm.js";
-import "./session-CThOl8m5.esm.js";
+import "./session-B9KT6qnE.esm.js";
 import { r as videoSelfieWasmPipelines } from "./videoSelfieSteps-DHcibfYH.esm.js";
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {
@@ -195,7 +196,8 @@ const getFlow = async (signal, options = {}) => {
 	} catch (error) {
 		toIncodeApiError(endpoints.flow, error);
 	}
-	if (data.mandatoryConsentCheck !== false) await sessionPromise;
+	await sessionPromise;
+	await updateFeatureManagementUser({ customIDs: { flow_id: data.flowId } });
 	const flow = prependMandatoryConsent(data);
 	const normalizedModules = normalizeFlowModules(flow, options);
 	return {

package/dist/id.esm.js

@@ -2,8 +2,8 @@ import { n as eventModuleNames } from "./events-Dy8PyVO5.esm.js";
 import { o as createActor, r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-P6aUarE9.esm.js";
-import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, h as MANUAL_UPLOAD_MAX_RETRIES, i as preloadIdRecordingProvider, l as uploadIdImage, m as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, o as startRecordingSession, p as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, r as initializeIdCapture, s as stopRecording, t as idCaptureMachine, u as uploadManualIdFile } from "./idCaptureStateMachine-D2H3vwwf.esm.js";
-import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-BoLeZff7.esm.js";
+import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, h as MANUAL_UPLOAD_MAX_RETRIES, i as preloadIdRecordingProvider, l as uploadIdImage, m as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, o as startRecordingSession, p as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, r as initializeIdCapture, s as stopRecording, t as idCaptureMachine, u as uploadManualIdFile } from "./idCaptureStateMachine-_1pROAbA.esm.js";
+import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-BBfWW9Y0.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-B-QfsCQY.esm.js";
 //#region src/modules/id/idCaptureOnlyStateMachine.ts
 function buildSubImage(canvas) {

package/dist/{idCaptureManager-BoLeZff7.esm.js → idCaptureManager-BBfWW9Y0.esm.js}

@@ -4,7 +4,7 @@ import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.
 import { n as setWasmDsFlagSync, t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-sJclps4C.esm.js";
 import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-DwNCUB2I.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-P6aUarE9.esm.js";
-import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-D2H3vwwf.esm.js";
+import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-_1pROAbA.esm.js";
 //#region src/modules/id/digitalUpload/instrumentation.ts
 const TERMINAL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isHoldingState(value) {

package/dist/{idCaptureStateMachine-D2H3vwwf.esm.js → idCaptureStateMachine-_1pROAbA.esm.js}

@@ -3,20 +3,20 @@ import { r as getToken, t as api } from "./api-BDTZNnca.esm.js";
 import { x as revokeObjectURL } from "./events-Dy8PyVO5.esm.js";
 import { t as endpoints } from "./endpoints-DLQ0g4-R.esm.js";
 import { t as addDeviceStats } from "./stats-Bu6bL_CX.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-B6n-FYf7.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-CrzyJ4Y0.esm.js";
 import { n as isDesktop } from "./platform-wmV7oTAJ.esm.js";
 import { a as and, n as sendTo, r as assign, s as not, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-DwNCUB2I.esm.js";
-import { _ as StreamCanvasProcessingSession, h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-4ODIm8fO.esm.js";
+import { _ as StreamCanvasProcessingSession, h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-B3oTx-NK.esm.js";
 import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 import { n as getBackCameraStream } from "./backCameraStream-Heg6vA1j.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-CkgnSJel.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
 import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-DguX5vFY.esm.js";
-import { i as flagIdManualReview, n as preloadOpenViduProvider } from "./recordingService-CkLJ00Pw.esm.js";
-import "./session-CThOl8m5.esm.js";
+import { i as flagIdManualReview, n as preloadOpenViduProvider } from "./recordingService-Comyo6yK.esm.js";
+import "./session-B9KT6qnE.esm.js";
 import { n as DEFAULT_ID_CAPTURE_THRESHOLDS$1, r as IdCaptureProvider } from "./idCaptureDefaults-Dzfws4i0.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
@@ -1548,7 +1548,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-BGu6zfoZ.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-C7HOhX6C.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,

package/dist/identity-reuse.d.ts

@@ -1,2 +1,2 @@
-import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-aTyLyYrr.js";
+import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-D6pD4hcZ.js";
 export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-aTyLyYrr.d.ts → identityReuseManager-D6pD4hcZ.d.ts}

@@ -125,7 +125,7 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     type: "hasSelection";
     params: unknown;
   };
-}>, never, "error" | "idle" | "finished" | "loading" | "documentsFound" | "submitting", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
+}>, never, "error" | "idle" | "finished" | "loading" | "submitting" | "documentsFound", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "identityReuse";
   readonly initial: "idle";
   readonly context: ({ input }: {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as isConfigured, c as setup, o as reset, t as SetupOptions } from "./setup-CgBvqGWw.js";
+import { a as isConfigured, c as setup, o as reset, t as SetupOptions } from "./setup-BBfVpTog.js";
 export { type SetupOptions, isConfigured, reset, setup };

package/dist/index.esm.js

@@ -1,2 +1,2 @@
-import { i as reset, o as setup, r as isConfigured } from "./setup-CeQfb7bE.esm.js";
+import { i as reset, o as setup, r as isConfigured } from "./setup-CBijDJ0d.esm.js";
 export { isConfigured, reset, setup };