@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/{faceMatchStateMachine-MDb30gCm.esm.js → faceMatchStateMachine-CJiO2yLO.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/face-match/constants.ts
 /**
 * Backend error code returned by face-match endpoints (e.g. `/omni/process/face`,
@@ -22,9 +22,8 @@ const ID_FACE_EXTRACTION_SKIPPED_CODE = 4084;
 function isFaceExtractionSkippedError(error) {
 	if (!error || typeof error !== "object") return false;
 	const err = error;
-	return err.status === ID_FACE_EXTRACTION_SKIPPED_CODE || err.data?.status === ID_FACE_EXTRACTION_SKIPPED_CODE;
+	return err.status === 4084 || err.data?.status === 4084;
 }
-
 //#endregion
 //#region src/modules/face-match/faceMatchServices.ts
 /**
@@ -105,7 +104,6 @@ async function fetchFaceMatchData(config, signal) {
 		result: resultRes
 	};
 }
-
 //#endregion
 //#region src/modules/face-match/faceMatchStateMachine.ts
 const faceMatchMachine = setup({
@@ -136,6 +134,7 @@ const faceMatchMachine = setup({
 	},
 	guards: {
 		isAnimationDisabled: ({ context }) => context.config.disableFaceMatchAnimation === true,
+		isFaceMatchSkipped: ({ context }) => context.config.skipFaceMatch === true,
 		isFaceExtractionSkipped: ({ event }) => isFaceExtractionSkippedError(event.error)
 	}
 }).createMachine({
@@ -148,7 +147,13 @@ const faceMatchMachine = setup({
 		error: void 0
 	}),
 	states: {
-		idle: { on: { LOAD: { target: "loading" } } },
+		idle: {
+			always: [{
+				target: "finished",
+				guard: "isFaceMatchSkipped"
+			}],
+			on: { LOAD: { target: "loading" } }
+		},
 		loading: { invoke: {
 			id: "fetchData",
 			src: "fetchData",
@@ -178,6 +183,5 @@ const faceMatchMachine = setup({
 		} } }
 	}
 });
-
 //#endregion
-export { ID_FACE_EXTRACTION_SKIPPED_CODE as n, isFaceExtractionSkippedError as r, faceMatchMachine as t };
+export { ID_FACE_EXTRACTION_SKIPPED_CODE as n, isFaceExtractionSkippedError as r, faceMatchMachine as t };

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

@@ -0,0 +1,615 @@
+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, options) {
+		if (!this._client) return createFallback("uninitialized");
+		try {
+			const statsigOptions = options === void 0 ? void 0 : { disableExposureLog: options.disableExposureLog };
+			return {
+				get: this._client.getParameterStore(name, statsigOptions).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();
+}
+/**
+* Name of the shared Statsig parameter store fronting SDK-module
+* experiments that need mutual exclusion. Callers read only this store via
+* {@link getFeatureParameterStore} (or the UI's `useFeatureManagement`) —
+* each param is wired, in the Statsig console, to a Layer's param, which in
+* turn delegates to the individual Experiment; the Layer guarantees at most
+* one experiment sharing it is ever allocated for a given user, so callers
+* reading different experiments from different surfaces don't need to
+* coordinate that themselves. See the ID module's `useIdExperiment`
+* (`packages/ui/src/modules/id/experiments/`) for the reference
+* integration.
+*/
+const ONBOARDING_WEB_SDK_PARAMETER_STORE = "onboarding_web_sdk_ps";
+let resolveReady;
+const freshReady = () => new Promise((resolve) => {
+	resolveReady = resolve;
+});
+let readyPromise = freshReady();
+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, options) {
+	return getProvider().getParameterStore(name, options);
+}
+/** 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);
+}
+/**
+* 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();
+	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
+//#region src/integrations/feature-management/experiments.ts
+const EXPERIMENT_ASSIGNED_ANALYTICS_EVENT_GATE = "experiment_assigned_analytics_event";
+const resolvedExperiments = /* @__PURE__ */ new Map();
+const exposedExperiments = /* @__PURE__ */ new Set();
+/**
+* Non-null fallback compared by reference. A `null` code fallback disables
+* Statsig validation; this sentinel distinguishes `unavailable` from console
+* `not_allocated`.
+*/
+const EXPERIMENT_UNAVAILABLE_SENTINEL = Object.freeze({
+	schema: "v1",
+	status: "not_allocated",
+	arm: "",
+	flagKey: "",
+	experimentId: "",
+	experimentName: "",
+	params: {}
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function defaultsResult(spec) {
+	return {
+		params: { ...spec.defaults },
+		assignment: null
+	};
+}
+function buildAssignment(payload) {
+	const flagKey = payload.flagKey;
+	const experimentId = payload.experimentId;
+	const experimentName = payload.experimentName;
+	const arm = payload.arm;
+	if (typeof flagKey !== "string" || typeof experimentId !== "string" || typeof experimentName !== "string" || typeof arm !== "string" || !flagKey || !experimentId || !experimentName || !arm) return null;
+	return {
+		flagKey,
+		experimentId,
+		experimentName,
+		variant: arm
+	};
+}
+function evaluateExperimentPayload(spec, raw) {
+	if (raw === EXPERIMENT_UNAVAILABLE_SENTINEL) return defaultsResult(spec);
+	if (!isRecord(raw) || raw.schema !== "v1") return defaultsResult(spec);
+	const status = raw.status;
+	if (status !== "ongoing" && status !== "completed" && status !== "not_allocated") return defaultsResult(spec);
+	if (status === "not_allocated") return defaultsResult(spec);
+	const rawParams = isRecord(raw.params) ? raw.params : {};
+	const parsedParams = spec.parseParams(rawParams);
+	if (parsedParams === null) return defaultsResult(spec);
+	const params = {
+		...spec.defaults,
+		...parsedParams
+	};
+	if (status === "completed") return {
+		params,
+		assignment: null
+	};
+	if (!getFeatureGate(EXPERIMENT_ASSIGNED_ANALYTICS_EVENT_GATE).enabled) return {
+		params,
+		assignment: null
+	};
+	return {
+		params,
+		assignment: buildAssignment(raw)
+	};
+}
+/**
+* Resolves an object-shaped experiment param with exposure suppressed (phase 1).
+* Pass `store` when the caller already holds a reactive parameter-store handle
+* (UI hooks) so the read logs exposure through that handle instead.
+*/
+function resolveExperiment(spec, options) {
+	return evaluateExperimentPayload(spec, (options?.store ?? getFeatureParameterStore("onboarding_web_sdk_ps", { disableExposureLog: true })).get(spec.storeParam, EXPERIMENT_UNAVAILABLE_SENTINEL));
+}
+/**
+* Phase 1 (core). Memoized for the SDK session: the first resolution is the arm
+* the user actually experiences, so later identity changes cannot retroactively
+* rewrite it. Exposure suppressed.
+*/
+function resolveExperimentOnce(spec) {
+	const memoized = resolvedExperiments.get(spec.storeParam);
+	if (memoized) return memoized;
+	const resolved = resolveExperiment(spec);
+	resolvedExperiments.set(spec.storeParam, resolved);
+	return resolved;
+}
+/**
+* Phase 2 (core). Performs the exposing read for its Statsig side effect at
+* most once per SDK session (keyed by `storeParam`), then returns the memoized
+* phase-1 assignment so analytics reports what the user saw.
+*/
+function exposeExperimentOnce(spec) {
+	const memoized = resolvedExperiments.get(spec.storeParam);
+	if (exposedExperiments.has(spec.storeParam)) return memoized?.assignment ?? null;
+	exposedExperiments.add(spec.storeParam);
+	const raw = getFeatureParameterStore(ONBOARDING_WEB_SDK_PARAMETER_STORE, { disableExposureLog: false }).get(spec.storeParam, EXPERIMENT_UNAVAILABLE_SENTINEL);
+	if (memoized) return memoized.assignment;
+	const resolved = evaluateExperimentPayload(spec, raw);
+	resolvedExperiments.set(spec.storeParam, resolved);
+	return resolved.assignment;
+}
+/** Clears phase-1 memoization and phase-2 exposure dedup. Called from SDK `reset()`. */
+function resetResolvedExperiments() {
+	resolvedExperiments.clear();
+	exposedExperiments.clear();
+}
+//#endregion
+//#region src/integrations/feature-management/experimentParams.ts
+const booleanParam = (defaultValue) => ({
+	default: defaultValue,
+	isValid: (value) => typeof value === "boolean"
+});
+const numberParam = (defaultValue, bounds = {}) => ({
+	default: defaultValue,
+	isValid: (value) => typeof value === "number" && Number.isFinite(value) && (!bounds.integer || Number.isInteger(value)) && (bounds.min === void 0 || value >= bounds.min) && (bounds.max === void 0 || value <= bounds.max)
+});
+/** Empty strings are console mistakes, not values. */
+const stringParam = (defaultValue) => ({
+	default: defaultValue,
+	isValid: (value) => typeof value === "string" && value.length > 0
+});
+const enumParam = (defaultValue, allowed) => ({
+	default: defaultValue,
+	isValid: (value) => typeof value === "string" && allowed.includes(value)
+});
+/**
+* Derives the `defaults` / `parseParams` half of an `ExperimentSpec` from a
+* schema. An omitted param keeps its code default (control users still get
+* shipped behavior); a present-but-invalid param rejects the whole payload so
+* a corrupt console edit can never produce a half-applied treatment.
+*/
+function defineExperimentParams(schema) {
+	const keys = Object.keys(schema);
+	return {
+		defaults: Object.freeze(keys.reduce((acc, key) => {
+			acc[key] = schema[key].default;
+			return acc;
+		}, {})),
+		parseParams(raw) {
+			const parsed = {};
+			for (const key of keys) {
+				if (!(key in raw) || raw[key] === void 0) continue;
+				const value = raw[key];
+				if (!schema[key].isValid(value)) return null;
+				parsed[key] = value;
+			}
+			return parsed;
+		}
+	};
+}
+//#endregion
+export { resetFeatureManagement as C, applyEnvironment as D, updateFeatureManagementUser as E, getEnvironment as O, optOutFeatureManagement as S, subscribeFeatureManagement as T, getIsFeatureManagementInitialized as _, stringParam as a, initializeFeatureManagement as b, resetResolvedExperiments as c, ONBOARDING_WEB_SDK_PARAMETER_STORE as d, getExperiment as f, getFeatureParameterStore as g, getFeatureManagementVersion as h, numberParam as i, resetEnvironment as k, resolveExperiment as l, getFeatureGate as m, defineExperimentParams as n, EXPERIMENT_UNAVAILABLE_SENTINEL as o, getFeatureDynamicConfig as p, enumParam as r, exposeExperimentOnce as s, booleanParam as t, resolveExperimentOnce as u, getIsFeatureManagementLocked as v, resetFeatureManagementProviderInstance as w, logEvent as x, getLayer as y };