@envive-ai/react-hooks 0.1.0 → 0.1.2

package/dist/api-NJEaveju.js

@@ -0,0 +1,4113 @@
+import { logger_default } from "./logger-pdEEY8T2.js";
+import { hasPropertyOfType, isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "./api-XRr_lAG6.js";
+import { ColorNames, CustomerServiceIntegrationMode, OrgShortName, PageVariantTestType, getOrgInfo } from "./types-BVsTRyxL.js";
+import { useEnviveConfig } from "./enviveConfigContext-CUGLpPGU.js";
+import { getAtomStore, sessionStorageUtil } from "./atomStore-BFtpknLM.js";
+import { findCustomerServiceImpl } from "./customerService-CUyZzowx.js";
+import { EventsDispatcher, SpiffyEvent } from "./events-ClCDFK7t.js";
+import { Configuration, ContextEnvEnum, ContextSourceEnum, CustomerServiceApi, DefaultApi, FormType, FulfillmentDisplayStatus, InferenceApi, OrganizationStatusEnum, PLPAttributeCategory, PageVisitCategory, ResponseCategory, ResponseError, SupportedEventProductCategory, UserEventCategory, V1OrgConfigGetSourceEnum } from "@spiffy-ai/commerce-api-client";
+import { atom } from "jotai";
+import { createInstance } from "@amplitude/analytics-browser";
+import { atomWithStorage, createJSONStorage } from "jotai/utils";
+import UAParser from "ua-parser-js";
+import { v4 } from "uuid";
+import { UserEventCategory as UserEventCategory$1 } from "@spiffy-ai/commerce-api-client/dist/models/UserEventCategory";
+import { createPortal } from "react-dom";
+
+//#region src/application/models/validators/validateSuggestion.ts
+const validateSuggestion = (data) => {
+	if (!isSuggestion(data)) return;
+	return {
+		id: data.id,
+		category: data.category,
+		content: data.content,
+		createdAt: data.created_at,
+		isAnswer: data.is_answer
+	};
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiPLPEventAttributes.ts
+const isApiPLPIdAttribute = (data) => {
+	if (data == null || typeof data !== "object") return false;
+	if (!("id" in data) || typeof data.id !== "string") return false;
+	return true;
+};
+const isApiPLPEventAttributes = (data) => {
+	if (data == null || typeof data !== "object") return false;
+	if (!("category" in data) || typeof data.category !== "string" || !Object.values(PLPAttributeCategory).includes(data.category)) return false;
+	if (!("attributes" in data) || typeof data.attributes !== "object" || !isApiPLPIdAttribute(data.attributes)) return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiFormSubmittedResponseAttributes.ts
+const isApiFormSubmittedResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logError("isApiFormSubmittedResponseAttributes", "data is null or not an object", data);
+		return false;
+	}
+	if (!hasPropertyOfType(data, "filled_schema", "object")) {
+		logger_default.logError("isApiFormSubmittedResponseAttributes", "filled_schema is not an object", data);
+		return false;
+	}
+	if (!hasPropertyOfType(data, "form_response_id", "string")) {
+		logger_default.logError("isApiFormSubmittedResponseAttributes", "form_response_id is not a string", data);
+		return false;
+	}
+	if (!("form_type" in data) || !Object.values(FormType).includes(data.form_type)) {
+		logger_default.logError("isApiFormSubmittedResponseAttributes", "form_type is not a valid form type enum", data);
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/validators/validateUserEvent.ts
+const validateUserEvent = (data) => {
+	if (!isApiUserEvent(data)) return;
+	if (data.category === UserEventCategory.PdpVisit && isApiPDPAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.PdpVisit,
+		attributes: {
+			productId: data.attributes.product_id,
+			parentProductId: data.attributes.parent_product_id,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === UserEventCategory.QueryTyped && isApiQueryTypedAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.QueryTyped,
+		attributes: { query: data.attributes.query }
+	};
+	if (data.category === UserEventCategory.Search && isApiSearchAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.Search,
+		attributes: {
+			searchTerm: data.attributes.search_term,
+			selectedFilters: data.attributes.selected_filters
+		}
+	};
+	if (data.category === UserEventCategory.SuggestionClicked && isApiSuggestionClickedAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.SuggestionClicked,
+		attributes: { suggestionId: data.attributes.suggestion_id }
+	};
+	if (data.category === UserEventCategory.PlpVisit && isApiPLPEventAttributes(data.attributes)) {
+		if (isApiPLPIdAttribute(data.attributes)) return {
+			eventId: data.event_id,
+			createdAt: data.created_at,
+			category: UserEventCategory.PlpVisit,
+			attributes: {
+				category: data.attributes.category,
+				attributes: { id: data.attributes.id }
+			}
+		};
+	}
+	if (data.category === UserEventCategory.FormSubmitted && isApiFormSubmittedResponseAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.FormSubmitted,
+		attributes: {
+			filledSchema: { ...data.attributes.filled_schema },
+			formResponseId: data.attributes.form_response_id,
+			formType: data.attributes.form_type
+		}
+	};
+	return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: UserEventCategory.AppLoaded
+	};
+};
+
+//#endregion
+//#region src/application/models/featureGates.ts
+let FeatureGates = /* @__PURE__ */ function(FeatureGates$1) {
+	FeatureGates$1["IsClientSessionEnabled"] = "is_client_session_enabled";
+	FeatureGates$1["IsNewFeatureEnabled"] = "is_new_feature_enabled";
+	FeatureGates$1["IsFineTunedModel8b"] = "is_fine_tuned_model_8b";
+	FeatureGates$1["IsIntegratedCXEnabled"] = "is_integrated_cx_enabled";
+	FeatureGates$1["IsNonShapewearEnabled"] = "is_non_shapewear_enabled";
+	FeatureGates$1["IsImageBannerEnabled"] = "is_image_banner_enabled";
+	FeatureGates$1["IsOrderLookupEnabled"] = "is_order_lookup_enabled";
+	FeatureGates$1["IsSummarizeReviewsEnabled"] = "is_summarize_reviews_enabled";
+	FeatureGates$1["IsGlobalSearchEnabled"] = "is_global_search_enabled";
+	FeatureGates$1["IsImagePromptEnabled"] = "is_image_prompt_enabled";
+	FeatureGates$1["IsWatermarkEnabled"] = "is_watermark_enabled";
+	FeatureGates$1["IsInferenceRegion0"] = "is_inference_region_0";
+	FeatureGates$1["IsGraphQLUIConfigsEnabled"] = "is_graphql_ui_configs_enabled";
+	FeatureGates$1["IsGraphQLPageConfigsEnabled"] = "is_graphql_page_configs_enabled";
+	FeatureGates$1["IsGraphQLComponentConfigsEnabled"] = "is_graphql_component_configs_enabled";
+	FeatureGates$1["IsChatVariantEnabled"] = "is_chat_variant_enabled";
+	FeatureGates$1["IsChatVariantAEnabled"] = "is_chat_variant_a_enabled";
+	FeatureGates$1["IsChatVariantBEnabled"] = "is_chat_variant_b_enabled";
+	FeatureGates$1["IsUserQueryAlwaysEnabled"] = "is_user_query_always_enabled";
+	return FeatureGates$1;
+}({});
+
+//#endregion
+//#region src/application/models/chatElementDisplayLocation.ts
+let ChatElementDisplayLocation = /* @__PURE__ */ function(ChatElementDisplayLocation$1) {
+	ChatElementDisplayLocation$1["IN_CHAT"] = "in_chat";
+	ChatElementDisplayLocation$1["CHAT_PREVIEW"] = "chat_preview";
+	ChatElementDisplayLocation$1["FLOATING_BUTTON"] = "floating_button";
+	ChatElementDisplayLocation$1["HELP_ME_CHOOSE"] = "help_me_choose";
+	ChatElementDisplayLocation$1["PLP_IMAGE_BANNER"] = "plp_image_banner";
+	ChatElementDisplayLocation$1["TOP_REVIEWS_SNIPPET"] = "top_reviews_snippet";
+	ChatElementDisplayLocation$1["BOTTOM_REVIEWS_SNIPPET"] = "bottom_reviews_snippet";
+	ChatElementDisplayLocation$1["BLOCK_BACK_BUTTON"] = "block_back_button";
+	ChatElementDisplayLocation$1["SWITCH_TO_AGENT"] = "switch_to_agent";
+	ChatElementDisplayLocation$1["CONVERSATIONAL_SEARCH"] = "conversational_search";
+	ChatElementDisplayLocation$1["GLOBAL_SEARCH_ENTRYPOINT"] = "global_search_entrypoint";
+	ChatElementDisplayLocation$1["SEARCH_NAV_ENTRYPOINT"] = "search_nav_entrypoint";
+	ChatElementDisplayLocation$1["SEARCH_PROMPT"] = "search_prompt";
+	ChatElementDisplayLocation$1["SEARCH_PROMPT_BUTTON"] = "search_prompt_button";
+	ChatElementDisplayLocation$1["PRODUCT_GRID"] = "product_grid";
+	ChatElementDisplayLocation$1["UNSPECIFIED"] = "unspecified";
+	ChatElementDisplayLocation$1["FILTER_MODAL"] = "filter_modal";
+	ChatElementDisplayLocation$1["PROMPT_CARD"] = "prompt_card";
+	ChatElementDisplayLocation$1["WINDOW_API_CALL"] = "window_api_call";
+	return ChatElementDisplayLocation$1;
+}({});
+
+//#endregion
+//#region src/application/models/domMutationContinuation.ts
+var DomMutationObserverContinuation = /* @__PURE__ */ function(DomMutationObserverContinuation$1) {
+	DomMutationObserverContinuation$1["CONTINUE"] = "CONTINUE";
+	DomMutationObserverContinuation$1["EXECUTING"] = "EXECUTING";
+	DomMutationObserverContinuation$1["STOP"] = "STOP";
+	return DomMutationObserverContinuation$1;
+}(DomMutationObserverContinuation || {});
+
+//#endregion
+//#region src/application/models/domObservationStrategy.ts
+var DomObservationStrategy = /* @__PURE__ */ function(DomObservationStrategy$1) {
+	DomObservationStrategy$1["MutationObserver"] = "MutationObserver";
+	DomObservationStrategy$1["Polling"] = "Polling";
+	DomObservationStrategy$1["None"] = "None";
+	return DomObservationStrategy$1;
+}(DomObservationStrategy || {});
+
+//#endregion
+//#region src/application/models/events.ts
+let SpiffyEventName = /* @__PURE__ */ function(SpiffyEventName$1) {
+	SpiffyEventName$1["WidgetOpen"] = "spiffy:widgetopen";
+	SpiffyEventName$1["WidgetClose"] = "spiffy:widgetclose";
+	return SpiffyEventName$1;
+}({});
+
+//#endregion
+//#region src/application/models/googleAnalyticsEvents.ts
+var GoogleAnalyticsEvents = /* @__PURE__ */ function(GoogleAnalyticsEvents$1) {
+	GoogleAnalyticsEvents$1["ADD_TO_CART_v1"] = "add_to_cart";
+	GoogleAnalyticsEvents$1["ADD_TO_CART_v2"] = "addToCart";
+	return GoogleAnalyticsEvents$1;
+}(GoogleAnalyticsEvents || {});
+
+//#endregion
+//#region src/application/models/message.ts
+let MessageRole = /* @__PURE__ */ function(MessageRole$1) {
+	MessageRole$1["User"] = "user";
+	MessageRole$1["Assistant"] = "assistant";
+	return MessageRole$1;
+}({});
+let MessageType = /* @__PURE__ */ function(MessageType$1) {
+	MessageType$1["Text"] = "text";
+	MessageType$1["SuggestionClicked"] = "suggestion_clicked";
+	MessageType$1["Product"] = "product";
+	MessageType$1["ProductSearch"] = "product_search";
+	MessageType$1["Review"] = "review";
+	MessageType$1["QueryTyped"] = "query_typed";
+	MessageType$1["Separator"] = "separator";
+	MessageType$1["Page"] = "page";
+	MessageType$1["Search"] = "search";
+	MessageType$1["Attachment"] = "attachment";
+	MessageType$1["CXAgentResponse"] = "cx_agent_response";
+	MessageType$1["Form"] = "form";
+	MessageType$1["Order"] = "order";
+	MessageType$1["ProductSearchFilter"] = "product_search_filter";
+	return MessageType$1;
+}({});
+
+//#endregion
+//#region src/application/models/productExperiment.ts
+let ProductExperiment = /* @__PURE__ */ function(ProductExperiment$1) {
+	ProductExperiment$1["Default"] = "default";
+	return ProductExperiment$1;
+}({});
+
+//#endregion
+//#region src/application/models/spiffyWidgets.ts
+/**
+* Enum of all widget names. These are widgets that are rendered and integrated into
+* a merchant's website.
+*/
+let SpiffyWidgets = /* @__PURE__ */ function(SpiffyWidgets$1) {
+	SpiffyWidgets$1["ImageBanner"] = "image_banner";
+	SpiffyWidgets$1["ImagePromptCard"] = "image_prompt_card";
+	SpiffyWidgets$1["SingleImagePrompt"] = "single_image_prompt";
+	SpiffyWidgets$1["EmbeddedWidget"] = "embedded_widget";
+	SpiffyWidgets$1["FloatingButton"] = "floating_button";
+	SpiffyWidgets$1["SuggestionBar"] = "suggestion_bar";
+	SpiffyWidgets$1["SearchPrompt"] = "search_prompt";
+	SpiffyWidgets$1["GlobalSearch"] = "global_search";
+	SpiffyWidgets$1["SearchResults"] = "search_results";
+	SpiffyWidgets$1["GlobalSearchEntryPoint"] = "global_search_entry_point";
+	return SpiffyWidgets$1;
+}({});
+
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantOrgIdQuery.ts
+const getMerchantOrgIdQuery = `
+  query {
+    me {
+      org {
+        id
+      }
+    }
+  }
+`;
+
+//#endregion
+//#region src/application/models/guards/graphQL/isGraphQLColorsConfig.ts
+const REQUIRED_COLOR_FIELDS = [
+	"accent_primary",
+	"accent_secondary",
+	"background_dark",
+	"background_light",
+	"background_primary",
+	"background_saturated",
+	"background_secondary",
+	"background_secondary_dark",
+	"background_tertiary",
+	"border_dark",
+	"border_light",
+	"border_medium",
+	"border_outline",
+	"text_accent",
+	"text_light",
+	"text_link",
+	"text_primary",
+	"text_secondary"
+];
+const isGraphQLColorsConfig = (data) => {
+	if (typeof data !== "object" || data === null) {
+		logger_default.logError("Invalid graphql response for colors config", void 0, { data });
+		return false;
+	}
+	const missingFields = REQUIRED_COLOR_FIELDS.filter((field) => !(field in data) || typeof data[field] !== "string");
+	if (missingFields.length === REQUIRED_COLOR_FIELDS.length) {
+		logger_default.logError("All color fields are missing or null", void 0);
+		return false;
+	}
+	if (missingFields.length > 0) {
+		logger_default.logError("Missing or invalid color fields", void 0, {
+			data,
+			missingFields
+		});
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLColorsConfig.ts
+const validateGraphQLColorsConfig = (data) => {
+	if (!isGraphQLColorsConfig(data)) return;
+	return {
+		[ColorNames.TextPrimary]: data.text_primary,
+		[ColorNames.TextSecondary]: data.text_secondary,
+		[ColorNames.TextAccent]: data.text_accent,
+		[ColorNames.TextLink]: data.text_link,
+		[ColorNames.TextLight]: data.text_light,
+		[ColorNames.BackgroundPrimary]: data.background_primary,
+		[ColorNames.BackgroundSecondary]: data.background_secondary,
+		[ColorNames.BackgroundSecondaryDark]: data.background_secondary_dark,
+		[ColorNames.BackgroundTertiary]: data.background_tertiary,
+		[ColorNames.BackgroundDark]: data.background_dark,
+		[ColorNames.BorderLight]: data.border_light,
+		[ColorNames.BorderMedium]: data.border_medium,
+		[ColorNames.BorderDark]: data.border_dark,
+		[ColorNames.BorderOutline]: data.border_outline,
+		[ColorNames.AccentPrimary]: data.accent_primary,
+		[ColorNames.AccentSecondary]: data.accent_secondary,
+		[ColorNames.BackgroundLight]: data.background_light,
+		[ColorNames.BackgroundSaturated]: data.background_saturated
+	};
+};
+
+//#endregion
+//#region src/application/models/utils/snakeToCamelTransformer.ts
+/**
+* Generic utility to transform snake_case object keys to camelCase at runtime.
+* This is the runtime equivalent of the CamelCasedPropertiesDeep type utility.
+*/
+const PRESERVED_ACRONYMS = [
+	"PLP",
+	"PDP",
+	"SVG"
+];
+/**
+* Converts a snake_case string to camelCase
+* Handles specific acronyms like PLP and PDP correctly
+*/
+const toCamelCase = (str) => {
+	let processedStr = str;
+	for (const acronym of PRESERVED_ACRONYMS) {
+		const regex = new RegExp(`_${acronym}_?`, "gi");
+		if (processedStr.match(regex)) processedStr = processedStr.replace(regex, (v) => v.endsWith("_") ? `${acronym}_` : `${acronym}`);
+	}
+	return processedStr.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+};
+/**
+* Converts a camelCase string to snake_case
+* Handles consecutive capital letters correctly (e.g., "PDP" -> "pdp", not "p_d_p")
+* Preserves specific acronyms like PLP and PDP as lowercase in snake_case
+*/
+const toSnakeCase = (str) => str.replace(/([A-Z])(?=[a-z])/g, "_$1").replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/^_/, "");
+/**
+* Recursively transforms all object keys from snake_case to camelCase
+*/
+const transformSnakeToCamel = (obj) => {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((val) => transformSnakeToCamel(val));
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const camelKey = toCamelCase(key);
+			result[camelKey] = transformSnakeToCamel(value);
+		}
+		return result;
+	}
+	return obj;
+};
+/**
+* Recursively transforms all object keys from camelCase to snake_case
+*/
+const transformCamelToSnake = (obj) => {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map(transformCamelToSnake);
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const snakeKey = toSnakeCase(key);
+			result[snakeKey] = transformCamelToSnake(value);
+		}
+		return result;
+	}
+	return obj;
+};
+
+//#endregion
+//#region src/application/service/domMutations/domInsertionService.ts
+var DOMInsertionType = /* @__PURE__ */ function(DOMInsertionType$1) {
+	DOMInsertionType$1["AFTER"] = "after";
+	DOMInsertionType$1["BEFORE"] = "before";
+	DOMInsertionType$1["ADJACENT_AFTER_BEGIN"] = "adjacent-after-begin";
+	DOMInsertionType$1["ADJACENT_BEFORE_BEGIN"] = "adjacent-before-begin";
+	DOMInsertionType$1["ADJACENT_AFTER_END"] = "adjacent-after-end";
+	DOMInsertionType$1["ADJACENT_BEFORE_END"] = "adjacent-before-end";
+	DOMInsertionType$1["APPEND_CHILD"] = "append-child";
+	DOMInsertionType$1["NONE"] = "none";
+	return DOMInsertionType$1;
+}(DOMInsertionType || {});
+const DOMInsertionTypeToInsertPosition = (type) => {
+	switch (type) {
+		case DOMInsertionType.ADJACENT_AFTER_BEGIN: return "afterbegin";
+		case DOMInsertionType.BEFORE:
+		case DOMInsertionType.ADJACENT_BEFORE_BEGIN: return "beforebegin";
+		case DOMInsertionType.ADJACENT_BEFORE_END: return "beforeend";
+		case DOMInsertionType.AFTER:
+		case DOMInsertionType.ADJACENT_AFTER_END:
+		default: return "afterend";
+	}
+};
+var DOMInsertionService = class {
+	static insert(targetElement, nodeToInsert, insertionType) {
+		switch (insertionType) {
+			case DOMInsertionType.AFTER:
+				targetElement.after(nodeToInsert);
+				break;
+			case DOMInsertionType.BEFORE:
+				targetElement.before(nodeToInsert);
+				break;
+			case DOMInsertionType.ADJACENT_AFTER_BEGIN:
+				targetElement.insertAdjacentElement("afterbegin", nodeToInsert);
+				break;
+			case DOMInsertionType.ADJACENT_BEFORE_BEGIN:
+				targetElement.insertAdjacentElement("beforebegin", nodeToInsert);
+				break;
+			case DOMInsertionType.ADJACENT_AFTER_END:
+				targetElement.insertAdjacentElement("afterend", nodeToInsert);
+				break;
+			case DOMInsertionType.ADJACENT_BEFORE_END:
+				targetElement.insertAdjacentElement("beforeend", nodeToInsert);
+				break;
+			case DOMInsertionType.APPEND_CHILD:
+				targetElement.appendChild(nodeToInsert);
+				break;
+			case DOMInsertionType.NONE: break;
+			default: throw new Error(`Invalid insertion type: ${insertionType}`);
+		}
+	}
+	/**
+	* Get the insertion point for the widget.
+	* @param selector - The selector to find the insertion point.
+	* @param selectionIndex - For multiple matches, pick the nth element. Can be negative to insert from the end (-1 is the last element). (optional, default first)
+	* @returns The insertion point element or null if not found.
+	*/
+	static getInsertionPoint(selector, selectionIndex) {
+		let elem = null;
+		if (selectionIndex === void 0 || selectionIndex === 0) {
+			elem = document.querySelector(selector);
+			if (elem?.parentElement) return elem;
+		} else {
+			const elems = document.querySelectorAll(selector);
+			const minLength = selectionIndex > 0 ? selectionIndex + 1 : -selectionIndex;
+			const index = selectionIndex > 0 ? selectionIndex : elems.length + selectionIndex;
+			if (elems.length >= minLength && elems[index].parentElement) return elems[index];
+		}
+		return null;
+	}
+};
+
+//#endregion
+//#region src/application/service/domMutations/GridInsertionService.ts
+var GridInsertionType = /* @__PURE__ */ function(GridInsertionType$1) {
+	GridInsertionType$1["FIXED_1"] = "fixed-1";
+	GridInsertionType$1["FIXED_2"] = "fixed-2";
+	GridInsertionType$1["FIXED_3"] = "fixed-3";
+	GridInsertionType$1["FIXED_4"] = "fixed-4";
+	GridInsertionType$1["FIXED_5"] = "fixed-5";
+	GridInsertionType$1["FIXED_6"] = "fixed-6";
+	GridInsertionType$1["FIXED_7"] = "fixed-7";
+	GridInsertionType$1["FIXED_8"] = "fixed-8";
+	GridInsertionType$1["FIXED_9"] = "fixed-9";
+	GridInsertionType$1["FIXED_12"] = "fixed-12";
+	GridInsertionType$1["FIXED_13"] = "fixed-13";
+	GridInsertionType$1["ROW_1"] = "row-1";
+	GridInsertionType$1["ROW_2"] = "row-2";
+	GridInsertionType$1["ROW_3"] = "row-3";
+	GridInsertionType$1["ROW_4"] = "row-4";
+	return GridInsertionType$1;
+}(GridInsertionType || {});
+var GridInsertionService = class GridInsertionService {
+	static insert(gridInsertionType, targetElement, nodeToInsert, insertionType) {
+		switch (gridInsertionType) {
+			case GridInsertionType.FIXED_1:
+				GridInsertionService.fixedInsert(targetElement, 1, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_2:
+				GridInsertionService.fixedInsert(targetElement, 2, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_3:
+				GridInsertionService.fixedInsert(targetElement, 3, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_4:
+				GridInsertionService.fixedInsert(targetElement, 4, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_5:
+				GridInsertionService.fixedInsert(targetElement, 5, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_6:
+				GridInsertionService.fixedInsert(targetElement, 6, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_7:
+				GridInsertionService.fixedInsert(targetElement, 7, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_8:
+				GridInsertionService.fixedInsert(targetElement, 8, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_9:
+				GridInsertionService.fixedInsert(targetElement, 9, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_12:
+				GridInsertionService.fixedInsert(targetElement, 12, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.FIXED_13:
+				GridInsertionService.fixedInsert(targetElement, 13, nodeToInsert, insertionType);
+				break;
+			case GridInsertionType.ROW_1:
+				GridInsertionService.rowInsert(targetElement, nodeToInsert, 1);
+				break;
+			case GridInsertionType.ROW_2:
+				GridInsertionService.rowInsert(targetElement, nodeToInsert, 2);
+				break;
+			case GridInsertionType.ROW_3:
+				GridInsertionService.rowInsert(targetElement, nodeToInsert, 3);
+				break;
+			case GridInsertionType.ROW_4:
+				GridInsertionService.rowInsert(targetElement, nodeToInsert, 4);
+				break;
+			default: logger_default.logError(`Skipping grid insertion: invalid grid insertion type "${gridInsertionType}". \
+          Valid types are: ${Object.keys(GridInsertionType).join(", ")}`, void 0);
+		}
+	}
+	/**
+	* Inserts a node into a grid row at the specified index starting from index 1. If the index
+	* is higher than the total number of rows, the node will be inserted at the end of the grid.
+	* This function does not make any assumptions about the column span of the inserted node - that
+	* should be handled by the orgConfig instead.
+	*
+	* @param targetElement - The target element to insert the node into.
+	* @param nodeToInsert - The node to insert into the grid.
+	* @param rowIndex - The index of the row to insert the node into.
+	*/
+	static rowInsert(targetElement, nodeToInsert, rowIndex) {
+		const node = nodeToInsert;
+		node.style.gridRow = rowIndex.toString();
+		node.style.gridColumn = "1/-1";
+		DOMInsertionService.insert(targetElement, node, DOMInsertionType.APPEND_CHILD);
+	}
+	static fixedInsert(targetElement, insertionGridIndex, nodeToInsert, insertionType) {
+		const childCount = targetElement.children.length;
+		const actualIndex = Math.min(insertionGridIndex - 1, childCount - 1);
+		const targetChild = targetElement.children[actualIndex];
+		if (!targetChild) {
+			logger_default.logWarn("Skipping grid insertion: grid has no elements", void 0);
+			return;
+		}
+		DOMInsertionService.insert(targetChild, nodeToInsert, insertionType);
+	}
+};
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLFrontendConfig.ts
+const validateAndTransformPageVariants = (config) => {
+	const { variantChecks, widgetMounting,...rest } = transformSnakeToCamel(config);
+	const variantTests = Array.isArray(variantChecks) ? variantChecks.map(({ checkType,...restCheck }) => ({
+		...restCheck,
+		testType: checkType
+	})) : [];
+	const normalizedWidgetMounting = Array.isArray(widgetMounting) ? widgetMounting.map(({ mountingPointWidgets,...restMounting }) => ({
+		...restMounting,
+		...Array.isArray(mountingPointWidgets) ? { mountingPointWidgets: mountingPointWidgets.map(({ checks,...restWidget }) => ({
+			...restWidget,
+			tests: Array.isArray(checks) ? checks.map(({ checkType,...restCheck }) => ({
+				...restCheck,
+				testType: checkType
+			})) : []
+		})) } : {}
+	})) : [];
+	const normalizedConfig = {
+		...rest,
+		...variantTests ? { variantTests } : {},
+		...normalizedWidgetMounting ? { widgetMounting: normalizedWidgetMounting } : {}
+	};
+	const variantId = normalizedConfig.variantId;
+	const variantType = normalizedConfig.variantType;
+	if (typeof variantId !== "string" || !variantId) throw new Error(`Missing or invalid variantId for pageVariant`);
+	if (typeof variantType !== "string" || !variantType) throw new Error(`Missing or invalid variantType for pageVariant '${variantId}'`);
+	if (!Array.isArray(variantTests)) throw new Error(`Missing or invalid variantTests for pageVariant '${variantId}'. Must be an array`);
+	for (const test of variantTests) {
+		if (!test.testType || typeof test.testType !== "string") throw new Error(`Invalid variantTest.testType for pageVariant '${variantId}'`);
+		if (!Object.values(PageVariantTestType).includes(test.testType)) throw new Error(`Invalid testType '${test.testType}' for pageVariant '${variantId}'. Valid types: ${Object.values(PageVariantTestType).join(", ")}`);
+	}
+	if (!Array.isArray(normalizedWidgetMounting)) throw new Error(`Missing or invalid widgetMounting for pageVariant '${variantId}'. Must be an array`);
+	for (const mounting of normalizedWidgetMounting) {
+		if (typeof mounting.mountingConfigId !== "string" || !mounting.mountingConfigId) throw new Error(`Invalid mountingConfigId in widgetMounting for pageVariant '${variantId}'`);
+		if (mounting.widgetConfigId && typeof mounting.widgetConfigId !== "string") throw new Error(`Invalid widgetConfigId in widgetMounting for pageVariant '${variantId}'`);
+		if (mounting.mountingPointWidgets) for (const widget of mounting.mountingPointWidgets) {
+			if (typeof widget.widgetConfigId !== "string" || !widget.widgetConfigId) throw new Error(`Invalid widgetConfigId in mountingPointWidgets for pageVariant '${variantId}'`);
+			if (!Array.isArray(widget.tests)) throw new Error(`Invalid or missing tests in mountingPointWidgets for pageVariant '${variantId}'`);
+		}
+	}
+	if (variantType === "plp") {
+		if (typeof normalizedConfig.plpIdExtractor !== "string" || !normalizedConfig.plpIdExtractor) throw new Error(`Missing or invalid plpIdExtractor for PLP pageVariant '${variantId}'`);
+	}
+	if (variantType === "pdp") {
+		if (typeof normalizedConfig.productIdExtractor !== "string" || !normalizedConfig.productIdExtractor) throw new Error(`Missing or invalid productIdExtractor for PDP pageVariant '${variantId}'`);
+		if (normalizedConfig.parentProductIdExtractor && typeof normalizedConfig.parentProductIdExtractor !== "string") throw new Error(`Invalid parentProductIdExtractor for PDP pageVariant '${variantId}'. Must be string if provided`);
+	}
+	return normalizedConfig;
+};
+const validateAndTransformMountingConfig = (config, configKey) => {
+	const normalizedConfig = { ...config };
+	if (normalizedConfig.checkId && !normalizedConfig.testId) {
+		normalizedConfig.testId = normalizedConfig.checkId;
+		delete normalizedConfig.checkId;
+	}
+	if (typeof normalizedConfig.mountingConfigId !== "string" || !normalizedConfig.mountingConfigId) throw new Error(`Missing or invalid mountingConfigId for config '${configKey}'`);
+	if (typeof normalizedConfig.containerId !== "string" || !normalizedConfig.containerId) throw new Error(`Missing or invalid containerId for config '${configKey}'`);
+	if (typeof normalizedConfig.testId !== "string" || !normalizedConfig.testId) throw new Error(`Missing or invalid testId for config '${configKey}'`);
+	if (!normalizedConfig.insertionPoint || typeof normalizedConfig.insertionPoint !== "object" || Array.isArray(normalizedConfig.insertionPoint)) throw new Error(`Missing or invalid insertionPoint for config '${configKey}'`);
+	const insertionPoint = normalizedConfig.insertionPoint;
+	if (typeof insertionPoint.selector !== "string" || !insertionPoint.selector) throw new Error(`Missing or invalid insertionPoint.selector for config '${configKey}'`);
+	if (typeof insertionPoint.insertionType !== "string" || !insertionPoint.insertionType) throw new Error(`Missing or invalid insertionPoint.insertionType for config '${configKey}'`);
+	if (!Object.values(DOMInsertionType).includes(insertionPoint.insertionType)) throw new Error(`Invalid insertionPoint.insertionType '${insertionPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+	if (insertionPoint.selectionIndex != null && typeof insertionPoint.selectionIndex !== "number") throw new Error(`Invalid insertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
+	let parentInsertionPoint;
+	if (normalizedConfig.parentInsertionPoint) {
+		if (typeof normalizedConfig.parentInsertionPoint !== "object" || Array.isArray(normalizedConfig.parentInsertionPoint)) throw new Error(`Invalid parentInsertionPoint for config '${configKey}'. Must be an object`);
+		const parentPoint = normalizedConfig.parentInsertionPoint;
+		if (typeof parentPoint.selector !== "string" || !parentPoint.selector) throw new Error(`Missing or invalid parentInsertionPoint.selector for config '${configKey}'`);
+		if (typeof parentPoint.insertionType !== "string" || !parentPoint.insertionType) throw new Error(`Missing or invalid parentInsertionPoint.insertionType for config '${configKey}'`);
+		if (!Object.values(DOMInsertionType).includes(parentPoint.insertionType)) throw new Error(`Invalid parentInsertionPoint.insertionType '${parentPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+		if (parentPoint.selectionIndex != null && typeof parentPoint.selectionIndex !== "number") throw new Error(`Invalid parentInsertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
+		parentInsertionPoint = {
+			selector: parentPoint.selector,
+			insertionType: parentPoint.insertionType,
+			selectionIndex: parentPoint.selectionIndex
+		};
+	}
+	let wrappingElement;
+	if (normalizedConfig.wrappingElement) {
+		if (typeof normalizedConfig.wrappingElement !== "object" || Array.isArray(normalizedConfig.wrappingElement)) throw new Error(`Invalid wrappingElement for config '${configKey}'. Must be an object`);
+		const wrapping = normalizedConfig.wrappingElement;
+		if (typeof wrapping.className !== "string" || !wrapping.className) throw new Error(`Missing or invalid wrappingElement.className for config '${configKey}'`);
+		if (typeof wrapping.element !== "string" || !wrapping.element) throw new Error(`Missing or invalid wrappingElement.element for config '${configKey}'`);
+		if (typeof wrapping.insertionType !== "string" || !wrapping.insertionType) throw new Error(`Missing or invalid wrappingElement.insertionType for config '${configKey}'`);
+		if (!Object.values(DOMInsertionType).includes(wrapping.insertionType)) throw new Error(`Invalid wrappingElement.insertionType '${wrapping.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+		wrappingElement = {
+			className: wrapping.className,
+			element: wrapping.element,
+			insertionType: wrapping.insertionType
+		};
+	}
+	if (normalizedConfig.divCheckSelector != null && typeof normalizedConfig.divCheckSelector !== "string") throw new Error(`Invalid divCheckSelector for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.className != null && typeof normalizedConfig.className !== "string") throw new Error(`Invalid className for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.suppressionSelector != null && typeof normalizedConfig.suppressionSelector !== "string") throw new Error(`Invalid suppressionSelector for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.dataAttributes != null && (typeof normalizedConfig.dataAttributes !== "object" || Array.isArray(normalizedConfig.dataAttributes))) throw new Error(`Invalid dataAttributes for config '${configKey}'. Must be an object or null/undefined`);
+	if (normalizedConfig.style != null && (typeof normalizedConfig.style !== "object" || Array.isArray(normalizedConfig.style))) throw new Error(`Invalid style for config '${configKey}'. Must be an object or null/undefined`);
+	let gridInsertionType;
+	if (normalizedConfig.gridInsertionType) {
+		if (typeof normalizedConfig.gridInsertionType !== "string" || !normalizedConfig.gridInsertionType) throw new Error(`Invalid gridInsertionType for config '${configKey}'. Must be a string`);
+		if (!Object.values(GridInsertionType).includes(normalizedConfig.gridInsertionType)) throw new Error(`Invalid gridInsertionType '${normalizedConfig.gridInsertionType}' for config '${configKey}'. Valid types: ${Object.values(GridInsertionType).join(", ")}`);
+		gridInsertionType = normalizedConfig.gridInsertionType;
+	}
+	const result = {
+		mountingConfigId: normalizedConfig.mountingConfigId,
+		containerId: normalizedConfig.containerId,
+		testId: normalizedConfig.testId,
+		insertionPoint: {
+			selector: insertionPoint.selector,
+			insertionType: insertionPoint.insertionType,
+			...insertionPoint.selectionIndex != null && { selectionIndex: insertionPoint.selectionIndex }
+		}
+	};
+	if (parentInsertionPoint) result.parentInsertionPoint = parentInsertionPoint;
+	if (gridInsertionType) result.gridInsertionType = gridInsertionType;
+	if (wrappingElement) result.wrappingElement = wrappingElement;
+	if (normalizedConfig.divCheckSelector) result.divCheckSelector = normalizedConfig.divCheckSelector;
+	if (normalizedConfig.className) result.className = normalizedConfig.className;
+	if (normalizedConfig.suppressionSelector) result.suppressionSelector = normalizedConfig.suppressionSelector;
+	if (normalizedConfig.dataAttributes) result.dataAttributes = normalizedConfig.dataAttributes;
+	if (normalizedConfig.style) result.style = normalizedConfig.style;
+	return result;
+};
+const validateAndTransformWidgetConfig = (config, configKey) => {
+	const normalizedConfig = transformSnakeToCamel(config);
+	if (typeof normalizedConfig.widgetConfigId !== "string" || !normalizedConfig.widgetConfigId) throw new Error(`Missing or invalid widgetConfigId for widget config '${configKey}'`);
+	if (typeof normalizedConfig.type !== "string" || !normalizedConfig.type) throw new Error(`Missing or invalid type for widget config '${configKey}'`);
+	if (normalizedConfig.contentId != null && typeof normalizedConfig.contentId !== "string") throw new Error(`Invalid contentId for widget config '${configKey}'. Must be a string or null/undefined`);
+	return normalizedConfig;
+};
+const validateGraphQLFrontendConfig = (data) => {
+	if (data === null || data === void 0) return;
+	if (typeof data !== "object" || Array.isArray(data)) {
+		logger_default.logWarn("Invalid GraphQL frontend config data: not an object", void 0, { data });
+		return;
+	}
+	const obj = data;
+	if ("merchant_override_css" in obj && typeof obj.merchant_override_css !== "string" && obj.merchant_override_css !== null) {
+		logger_default.logWarn("Invalid GraphQL frontend config data: merchant_override_css must be a string or null", void 0, { data });
+		return;
+	}
+	if ("page_variants" in obj) {
+		if (obj.page_variants !== void 0 && obj.page_variants !== null && !Array.isArray(obj.page_variants)) {
+			logger_default.logWarn("Invalid GraphQL frontend config data: page_variants must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("mounting_configs" in obj) {
+		if (obj.mounting_configs !== void 0 && obj.mounting_configs !== null && !Array.isArray(obj.mounting_configs)) {
+			logger_default.logWarn("Invalid GraphQL frontend config data: mounting_configs must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("widget_configs" in obj) {
+		if (obj.widget_configs !== void 0 && obj.widget_configs !== null && !Array.isArray(obj.widget_configs)) {
+			logger_default.logWarn("Invalid GraphQL frontend config data: widget_configs must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("ui_configs" in obj && typeof obj.ui_configs !== "object" && obj.ui_configs !== null) {
+		logger_default.logWarn("Invalid GraphQL frontend config data: ui_configs must be an object or null/undefined", void 0, { data });
+		return;
+	}
+	try {
+		const transformedData = transformSnakeToCamel(obj);
+		if (transformedData.pageVariants && Array.isArray(transformedData.pageVariants)) {
+			const pageVariantsArray = transformedData.pageVariants;
+			const validatedPageVariants = [];
+			for (const variant of pageVariantsArray) if (variant && typeof variant === "object" && typeof variant.variantId === "string") try {
+				const validatedVariant = validateAndTransformPageVariants(variant);
+				validatedPageVariants.push(validatedVariant);
+			} catch (error) {
+				logger_default.logWarn("Invalid page variant, skipping", error, {
+					variantId: variant.variantId,
+					variant
+				});
+			}
+			else logger_default.logWarn("Invalid page variant structure, skipping", void 0, { variant });
+			transformedData.pageVariants = validatedPageVariants;
+		}
+		if (transformedData.mountingConfigs && Array.isArray(transformedData.mountingConfigs)) {
+			const mountingConfigsArray = transformedData.mountingConfigs;
+			const mountingConfigsRecord = {};
+			for (const item of mountingConfigsArray) if (item && typeof item.key === "string" && item.config && typeof item.config === "object") try {
+				const config = item.config;
+				const validatedConfig = validateAndTransformMountingConfig(config, item.key);
+				mountingConfigsRecord[item.key] = validatedConfig;
+			} catch (error) {
+				logger_default.logWarn("Invalid mounting config, skipping", error, {
+					configKey: item.key,
+					config: item.config
+				});
+			}
+			else logger_default.logWarn("Invalid mounting config item structure, skipping", void 0, { item });
+			transformedData.mountingConfigs = mountingConfigsRecord;
+		}
+		if (transformedData.widgetConfigs && Array.isArray(transformedData.widgetConfigs)) {
+			const widgetConfigsArray = transformedData.widgetConfigs;
+			const widgetConfigsRecord = {};
+			for (const item of widgetConfigsArray) if (item && typeof item.key === "string" && item.config && typeof item.config === "object") try {
+				const config = item.config;
+				const validatedConfig = validateAndTransformWidgetConfig(config, item.key);
+				widgetConfigsRecord[item.key] = validatedConfig;
+			} catch (error) {
+				logger_default.logWarn("Invalid widget config, skipping", error, {
+					configKey: item.key,
+					config: item.config
+				});
+			}
+			else logger_default.logWarn("Invalid widget config item structure, skipping", void 0, { item });
+			transformedData.widgetConfigs = widgetConfigsRecord;
+		}
+		return transformedData;
+	} catch (error) {
+		logger_default.logWarn("Failed to validate and transform GraphQL frontend config data", error, { data });
+		return;
+	}
+};
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLOrgId.ts
+const validateGraphQLOrgId = (data) => {
+	if (typeof data !== "string" || data === "") return;
+	return data;
+};
+
+//#endregion
+//#region src/application/service/localStorageService.ts
+let LocalStorageKeys = /* @__PURE__ */ function(LocalStorageKeys$1) {
+	LocalStorageKeys$1["ChatId"] = "v1-spiffy-chat-session-id";
+	LocalStorageKeys$1["SpiffyOnOverride"] = "spiffy_on";
+	LocalStorageKeys$1["EnviveOnOverride"] = "envive_on";
+	return LocalStorageKeys$1;
+}({});
+var LocalStorageService = class {
+	static setItem(key, value) {
+		localStorage.setItem(key, value);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key,
+			newValue: value
+		}));
+	}
+	static getItem(key) {
+		return localStorage.getItem(key);
+	}
+	static setSpiffyOnFeatureFlag(value) {
+		if (value === true) localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, "true");
+		else if (value === false) localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, "false");
+	}
+	static getSpiffyOnFeatureFlag() {
+		return localStorage.getItem(LocalStorageKeys.SpiffyOnOverride);
+	}
+	static getLocalStorage() {
+		const ls = window?.localStorage;
+		if (!ls) logger_default.logError("localStorage is not available", void 0);
+		return ls;
+	}
+	static {
+		this.listenersCache = {};
+	}
+	static listenerForKey(listener) {
+		if (!this.listenersCache[listener.storageKey]) this.listenersCache[listener.storageKey] = (event) => {
+			if (event.key !== listener.storageKey) return;
+			logger_default.logDebug(`[spiffy-ai] Storage event key=${event.key}, value=`, event.newValue);
+			listener.listener(event);
+		};
+		return this.listenersCache[listener.storageKey];
+	}
+	/**
+	* Attach a listener to the window's storage event. Safe to call multiple times.
+	* @param listener
+	*/
+	static attachListener(listener) {
+		window.addEventListener("storage", this.listenerForKey(listener));
+	}
+	static detachListener(listener) {
+		window.removeEventListener("storage", this.listenerForKey(listener));
+	}
+};
+
+//#endregion
+//#region src/application/service/environmentService.ts
+var EnvironmentService = class {
+	static getApiEndpoint() {
+		const { baseUrl } = useEnviveConfig();
+		return baseUrl || "https://commerce-api.dev.spiffy.ai";
+	}
+	static getContextSource() {
+		if (window.IS_STORYBOOK) return ContextSourceEnum.Test;
+		const { contextSource } = useEnviveConfig();
+		if (contextSource) return contextSource;
+		if (LocalStorageService.getSpiffyOnFeatureFlag() === "true") return ContextSourceEnum.Playground;
+		return ContextSourceEnum.App;
+	}
+	static getIdentifyingPrefix() {
+		return "spiffy";
+	}
+	static {
+		this.getEnvironment = () => {
+			const { env } = useEnviveConfig();
+			if (!env) return "dev";
+			switch (env.toLowerCase()) {
+				case "production":
+				case "prod": return "prod";
+				default: return "dev";
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/application/utils/urlsParser.ts
+const parseHref = (href) => {
+	try {
+		const url = new URL(href);
+		const urlSearchParams = new URLSearchParams(url.search);
+		return {
+			url,
+			urlSearchParams
+		};
+	} catch (e) {
+		return {
+			url: void 0,
+			urlSearchParams: void 0
+		};
+	}
+};
+const createUrlWithQueryParams = (url, queryParams) => {
+	const urlObj = new URL(url, window.location.href);
+	Object.entries(queryParams).forEach(([value, key]) => urlObj.searchParams.append(value, key));
+	return urlObj.href;
+};
+const getQueryParam = (key) => {
+	return new URL(window.location.href).searchParams.get(key);
+};
+const buildSearchHash = (message) => `#evs=true&s=${message.id}&q=${message.metadata.generatedQuery}`;
+const buildSearchStartHash = (query) => `#evs=true&q=${query}`;
+const parseSearchHash = (hash) => {
+	if (!hash.startsWith("#evs=true")) return {
+		id: null,
+		query: null
+	};
+	const params = Object.fromEntries(hash.split("&").map((param) => param.split("=")));
+	return {
+		id: params.s ? decodeURIComponent(params.s) : null,
+		query: params.q ? decodeURIComponent(params.q) : null
+	};
+};
+window.history.pushState(null, "");
+
+//#endregion
+//#region src/application/service/sessionStorageService.ts
+var SessionStorageService = class {
+	static setItem(key, value) {
+		sessionStorage.setItem(key, value);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key,
+			newValue: value
+		}));
+	}
+	static getItem(key) {
+		return sessionStorage.getItem(key);
+	}
+	static getSessionStorage() {
+		const ls = window?.sessionStorage;
+		if (!ls) logger_default.logError("sessionStorage is not available", void 0);
+		return ls;
+	}
+};
+
+//#endregion
+//#region src/application/service/featureFlagService.ts
+const FEATURE_FLAGS_STORAGE_KEY = "spiffy-feature-flags";
+var FeatureFlagService = class {
+	constructor(featureGates) {
+		this.featureGates = featureGates;
+		this.getQueryParamFeatureGateOverrides = (featureGate) => {
+			const urlObj = new URL(window.location.href);
+			const params = new URLSearchParams(urlObj.search);
+			const value = Object.fromEntries(params.entries())[featureGate];
+			if (value != null) return value === "true";
+		};
+		this.getWindowFeatureGateOverrides = (featureGate) => {
+			const value = window._spiffy?.featureOverrides?.[String(featureGate)];
+			if (value != null) return value;
+		};
+		this.getStoredFeatureGateOverrides = (featureGate) => {
+			const featureFlags = SessionStorageService.getItem(FEATURE_FLAGS_STORAGE_KEY);
+			if (featureFlags) try {
+				return JSON.parse(featureFlags)[featureGate];
+			} catch (err) {
+				logger_default.logError("[spiffy-ai] getStoredFeatureGateOverrides: error parsing feature flags", err);
+			}
+		};
+	}
+	persistFeatureGateOverrides() {
+		const featureFlags = Object.values(FeatureGates).map((featureGate) => ({ [featureGate]: this.getFeatureFlagOverride(featureGate) })).filter((_, val) => val !== void 0).reduce((acc, curr) => ({
+			...acc,
+			...curr
+		}), {});
+		SessionStorageService.setItem(FEATURE_FLAGS_STORAGE_KEY, JSON.stringify(featureFlags));
+	}
+	getFeatureFlagOverride(featureGate) {
+		const queryOverride = this.getQueryParamFeatureGateOverrides(featureGate);
+		if (queryOverride != null) {
+			logger_default.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`);
+			return queryOverride;
+		}
+		const windowOverride = this.getWindowFeatureGateOverrides(featureGate);
+		if (windowOverride != null) {
+			logger_default.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`);
+			return windowOverride;
+		}
+		const storedOverride = this.getStoredFeatureGateOverrides(featureGate);
+		if (storedOverride != null) {
+			logger_default.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`);
+			return storedOverride;
+		}
+	}
+	isFeatureGateEnabled(featureGate) {
+		const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+		const featureFlagOverride = this.getFeatureFlagOverride(featureGate);
+		if (featureFlagOverride !== void 0) return featureFlagOverride;
+		if (gateValue == null || gateValue.value == null) {
+			logger_default.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`);
+			return false;
+		}
+		return gateValue.value;
+	}
+	isClientSessionEnabled() {
+		const gates = this.featureGates;
+		return gates == null || gates?.filter((gate) => gate.name === FeatureGates.IsClientSessionEnabled && gate.value === true).length > 0;
+	}
+	getFeatureFlags() {
+		return Object.fromEntries(Object.values(FeatureGates).map((featureGate) => [featureGate, this.isFeatureGateEnabled(featureGate)]));
+	}
+};
+
+//#endregion
+//#region src/application/service/windowDataLayerService.ts
+var WindowDataLayerService = class WindowDataLayerService {
+	constructor(gaConfig) {
+		this.gaConfig = gaConfig;
+		this.dataLayer = window.dataLayer;
+		this.originalDataLayerPush = this.dataLayer?.push;
+		this.merchantGoogleMeasurementId = this.gaConfig.measurementId || "default";
+	}
+	/**
+	* Pushes data to the dataLayer
+	* @param data
+	*  data has the shape: { event: 'event_name', ... }
+	*  Example:
+	*  {
+	*         "event": "add_to_cart",
+	*         "currency": "USD",
+	*         "value": 30.03,
+	*         "items": [
+	*           {
+	*             "item_id": "SKU_12345",
+	*             "item_name": "Stan and Friends Tee",
+	*             "affiliation": "Google Merchandise Store",
+	*             "coupon": "SUMMER_FUN",
+	*             "discount": 2.22,
+	*             "index": 0,
+	*             "item_brand": "Google",
+	*             "item_category": "Apparel",
+	*             "item_category2": "Adult",
+	*             "item_category3": "Shirts",
+	*             "item_category4": "Crew",
+	*             "item_category5": "Short sleeve",
+	*             "item_list_id": "related_products",
+	*             "item_list_name": "Related Products",
+	*             "item_variant": "green",
+	*             "location_id": "ChIJIQBpAG2ahYAR_6128GcTUEo",
+	*             "price": 10.01,
+	*             "quantity": 3
+	*           }
+	*         ]
+	* }
+	*/
+	push(data) {
+		this.dataLayer?.push(data);
+	}
+	static isDataLayerAvailable() {
+		const windowDataLayer = window.dataLayer;
+		if (windowDataLayer && windowDataLayer.push) return true;
+		logger_default.logDebug("[spiffy-ai] DataLayerEventsListener dataLayer not available");
+		return false;
+	}
+	static tryFlattenArguments(args) {
+		function isArguments(obj) {
+			return obj !== void 0 && Object.prototype.toString.call(obj) === "[object Arguments]";
+		}
+		try {
+			const all_arguments = [];
+			if (args.length > 0) for (let i = 0; i < args.length; i++) {
+				const arg = args[i];
+				if (isArguments(arg)) {
+					const flattened = WindowDataLayerService.tryFlattenArguments(arg);
+					all_arguments.push(...flattened);
+				} else all_arguments.push(arguments[i]);
+			}
+			return all_arguments;
+		} catch {
+			return args;
+		}
+	}
+	wrapWithProxyMethod(methodName, callback) {
+		if (!this.dataLayer) {
+			logger_default.logWarn("DataLayerEventsListener dataLayer not available", void 0);
+			return;
+		}
+		const originalMethod = this.dataLayer[methodName];
+		this.dataLayer[methodName] = function() {
+			try {
+				callback.apply(this, arguments);
+			} catch (e) {
+				logger_default.logError(`Error in dataLayer.${methodName}: `, e);
+			} finally {
+				originalMethod.apply(this, arguments);
+			}
+		};
+	}
+	static getSingletonInstanceOf(gaConfig) {
+		if (!WindowDataLayerService.instance) WindowDataLayerService.instance = new WindowDataLayerService(gaConfig);
+		return WindowDataLayerService.instance;
+	}
+	sendToGoogleAnalyticsCircularEventsSafe(eventName, eventProps) {
+		const This = this;
+		function doesEventExistInDataLayer(eventName$1) {
+			return This.dataLayer?.find((event) => event.event === eventName$1);
+		}
+		if (doesEventExistInDataLayer(eventName)) {
+			logger_default.logDebug(`[spiffy-ai] Event ${eventName} already exists in dataLayer. Skipping Google Analytics event.`);
+			return;
+		}
+		function gtag() {
+			if (This.originalDataLayerPush) This.originalDataLayerPush(arguments);
+			else logger_default.logDebug("No originalDataLayerPush found - no metrics being logged");
+		}
+		gtag("event", eventName, {
+			event: eventName,
+			send_to: this.merchantGoogleMeasurementId,
+			...eventProps
+		});
+	}
+	static {
+		this.getGoogleAnalyticsClientId = () => {
+			try {
+				const gaCookie = document.cookie.split(";").find((c) => c.trim().startsWith("_ga="));
+				if (!gaCookie) {
+					logger_default.logWarn("[spiffy-ai] No GA cookie found", void 0);
+					return;
+				}
+				return gaCookie.split(".").slice(2).join(".");
+			} catch (error) {
+				logger_default.logError("Error getting GA client ID:", error);
+				return;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/application/service/userIdentityService.ts
+const getUserAgentDetails = () => {
+	const result = new UAParser().getResult();
+	return {
+		os: result?.os?.name,
+		osVersion: result?.os?.version,
+		deviceBrand: result?.device?.vendor,
+		deviceManufacturer: result?.device?.vendor,
+		deviceModel: result?.device?.model,
+		browser: result?.browser?.name,
+		browserVersion: result?.browser?.version,
+		userAgent: result?.ua
+	};
+};
+var UserIdentityService = class UserIdentityService {
+	static {
+		this.USER_ID_OVERRIDE_KEY = "v1-spiffy-user-id-override";
+	}
+	static {
+		this.USER_ID_DEFAULT_KEY = "v1-spiffy-user-id-default";
+	}
+	static async identifyUser() {
+		try {
+			const cdpUserId = WindowDataLayerService.getGoogleAnalyticsClientId();
+			const userId = UserIdentityService.getUserIdOrDefault();
+			const userAgentDetails = getUserAgentDetails();
+			if (!cdpUserId) {
+				logger_default.logWarn("[spiffy-ai] No GA Client ID found, skipping identifyUser", void 0);
+				return;
+			}
+			await api_default.identifyUser(userId, cdpUserId, userAgentDetails);
+		} catch (error) {
+			logger_default.logError("[spiffy-ai] Error identifying user", error);
+		}
+	}
+	static getUserIdOrDefault() {
+		const userIdOverride = UserIdentityService.getUserIdOverrideFromLocalStorage();
+		if (userIdOverride) return userIdOverride;
+		const defaultUserId = UserIdentityService.getUserIdDefaultFromLocalStorage();
+		if (defaultUserId) return defaultUserId;
+		return this.setUserIdDefaultInLocalStorage(`spiffy-user-id-${v4()}`);
+	}
+	static getUserIdOverrideFromLocalStorage() {
+		return LocalStorageService.getLocalStorage()?.getItem(UserIdentityService.USER_ID_OVERRIDE_KEY) ?? void 0;
+	}
+	static getUserIdDefaultFromLocalStorage() {
+		return LocalStorageService.getLocalStorage()?.getItem(UserIdentityService.USER_ID_DEFAULT_KEY) ?? void 0;
+	}
+	static setUserIdDefaultInLocalStorage(userId) {
+		logger_default.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);
+		LocalStorageService.getLocalStorage()?.setItem(UserIdentityService.USER_ID_DEFAULT_KEY, userId);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key: UserIdentityService.USER_ID_DEFAULT_KEY,
+			newValue: userId
+		}));
+		return userId;
+	}
+	static setUserIdOverrideInLocalStorage(userId) {
+		logger_default.logInfo(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);
+		LocalStorageService.getLocalStorage()?.setItem(UserIdentityService.USER_ID_OVERRIDE_KEY, userId);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key: UserIdentityService.USER_ID_OVERRIDE_KEY,
+			newValue: userId
+		}));
+		return userId;
+	}
+	static clearUserIdOverrideInLocalStorage() {
+		logger_default.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);
+		LocalStorageService.getLocalStorage()?.removeItem(UserIdentityService.USER_ID_OVERRIDE_KEY);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key: UserIdentityService.USER_ID_OVERRIDE_KEY,
+			newValue: void 0
+		}));
+	}
+};
+
+//#endregion
+//#region src/atoms/chat/chatState.ts
+const userHasRepliedAtom = atom(false);
+const replyEventCategoryAtom = atom(UserEventCategory$1.AppLoaded);
+const userQueryAtom = atom();
+const suggestionAtom = atom(void 0);
+const askQuestionBtnClickedAtom = atom(false);
+const messagesAtom = atom([]);
+const userEventsAtom = atom([]);
+const suggestionsAtom = atom([]);
+const suggestionsLoadingAtom = atom(false);
+const responseStreamingAtom = atom(false);
+const chatIsOpenAtom = atom(false);
+const requestFailureAtom = atom(false);
+const formSubmitAtom = atom();
+const chatOnToggleAtom = atom(null, (get, set, triggerLocation) => {
+	const isOpen = get(chatIsOpenAtom);
+	set(chatIsOpenAtom, !isOpen);
+	if (!isOpen) {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
+		AmplitudeAdapter.trackEvent({
+			eventName: SpiffyMetricsEventName.ChatComponentExpanded,
+			eventProps: { message_metadata: { trigger_location: triggerLocation } }
+		});
+	} else {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
+		AmplitudeAdapter.trackEvent({ eventName: SpiffyMetricsEventName.ChatComponentCollapsed });
+	}
+});
+
+//#endregion
+//#region src/atoms/app/variant.ts
+const internalStorageUrlResolverAtom = atomWithStorage("spiffy-url-resolver", void 0, sessionStorageUtil, { getOnInit: true });
+const urlResolverAtom = atom((get) => {
+	const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+	if (maybeUrlResolver == null) return {};
+	return JSON.parse(maybeUrlResolver);
+}, (get, set, value) => {
+	const newCache = {
+		...get(urlResolverAtom),
+		[value.url]: value.response
+	};
+	set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+});
+const internalStorageSupportedEventAtom = atomWithStorage("spiffy-supported-event", void 0, sessionStorageUtil, { getOnInit: true });
+const internalSupportedEventAtom = atom(void 0);
+const supportedEventAtom = atom((get) => {
+	const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+	if (maybeSupportedEvent == null) return;
+	return JSON.parse(maybeSupportedEvent);
+}, (get, set, value) => {
+	if (value == null) {
+		set(internalStorageSupportedEventAtom, void 0);
+		set(internalSupportedEventAtom, void 0);
+		return;
+	}
+	const featureFlagService = get(featureFlagServiceAtom);
+	const variantCategory = get(internalSupportedEventAtom)?.category;
+	const shortName = get(orgShortNameAtom);
+	if (!featureFlagService.isFeatureGateEnabled(FeatureGates.IsNonShapewearEnabled) && variantCategory && variantCategory !== SupportedEventProductCategory.Shapewear && (shortName === OrgShortName.Spanx || shortName === OrgShortName.SpanxStaging)) {
+		const modifiedSupportedEvent = {
+			supported: false,
+			ready: value.ready,
+			category: value.category,
+			numberOfReviews: value.numberOfReviews,
+			collections: value.collections,
+			top_category: value.top_category,
+			merchant_tags: value.merchant_tags
+		};
+		set(internalSupportedEventAtom, modifiedSupportedEvent);
+		set(internalStorageSupportedEventAtom, JSON.stringify(modifiedSupportedEvent));
+		return;
+	}
+	set(internalSupportedEventAtom, value);
+	set(internalStorageSupportedEventAtom, JSON.stringify(value));
+});
+const internalVariantIdAtom = atom();
+const internalProductIdAtom = atom();
+const internalParentProductIdAtom = atom();
+const internalProductUrlAtom = atom();
+const internalPlpIdAtom = atom();
+const internalUrlAtom = atom();
+const internalPageVisitCategoryAtom = atom();
+const internalVariantAtom = atom("pdp");
+const variantIdAtom = atom((get) => get(internalVariantIdAtom));
+const productIdAtom = atom((get) => get(internalProductIdAtom));
+const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));
+const productUrlAtom = atom((get) => get(internalProductUrlAtom));
+const plpIdAtom = atom((get) => get(internalPlpIdAtom));
+const urlAtom = atom((get) => get(internalUrlAtom));
+const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));
+const variantAtom = atom((get) => get(internalVariantAtom));
+const hasParsedVariantInfoAtom = atom(false);
+const variantInfoAtom = atom((get) => {
+	const variant = get(variantAtom);
+	if (variant === "pdp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		productId: get(productIdAtom),
+		parentProductId: get(parentProductIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "plp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		plpId: get(plpIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "page_visit") return {
+		variantId: get(variantIdAtom),
+		variant,
+		url: get(urlAtom),
+		pageVisitCategory: get(pageVisitCategoryAtom)
+	};
+	throw new Error("Invalid variantInfo details");
+}, (_, set, newVariant) => {
+	set(internalVariantAtom, newVariant.variant);
+	set(internalVariantIdAtom, newVariant.variantId);
+	if (newVariant.variant === "pdp") {
+		set(internalProductIdAtom, newVariant.productId);
+		set(internalParentProductIdAtom, newVariant.parentProductId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "plp") {
+		set(internalPlpIdAtom, newVariant.plpId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "page_visit") {
+		set(internalUrlAtom, newVariant.url);
+		set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+	}
+});
+
+//#endregion
+//#region src/atoms/app/index.ts
+const internalUserIdAtom = atom(void 0);
+const userIdAtom = atom((get) => {
+	const maybeUserId = get(internalUserIdAtom);
+	if (maybeUserId) return maybeUserId;
+	return UserIdentityService.getUserIdOrDefault();
+}, (_, set, value) => {
+	set(internalUserIdAtom, value);
+});
+const appSourceAtom = atom((get) => get(sourceAtom) ?? ContextSourceEnum.App);
+const envAtom = atom(ContextEnvEnum.Dev);
+const chatIdAtom = atomWithStorage("v1-spiffy-chat-session-id", v4(), void 0, { getOnInit: true });
+const appDetailsAtom = atom((get) => ({
+	orgId: get(orgIdAtom),
+	orgShortName: get(orgShortNameAtom) ?? "spiffy-ai",
+	chatId: get(chatIdAtom),
+	userId: get(userIdAtom),
+	source: get(appSourceAtom),
+	env: get(envAtom),
+	variantInfo: get(variantInfoAtom)
+}));
+
+//#endregion
+//#region src/atoms/chat/messageQueue.ts
+const internalUserEventQueueAtom = atom([]);
+const userEventQueueAtom = atom((get) => {
+	const queue = get(internalUserEventQueueAtom);
+	return queue === void 0 ? [] : queue.filter((v) => v !== void 0);
+});
+/**
+* This atom is used to queue a new message for processing on `next_responses`
+* It receives a single `userEvent` that is added to the processing queue.
+* If the event has the same eventId as an existing message in the queue the NEW
+* event is ignored
+*/
+const queueUserEventAtom = atom(null, (get, set, userEvent) => {
+	if (userEvent === void 0) return;
+	set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);
+});
+/**
+* This atom exposes a function to reset the entire queue. All messages in the queue will be purged
+*/
+const clearUserEventAtom = atom(null, (_, set) => {
+	set(internalUserEventQueueAtom, []);
+});
+/**
+* This atom is used to mark events as processed and remove them from the queue
+* It accepts a list of eventId values and will remove all events with those eventIds from the queue.
+*/
+const processUserEventAtom = atom(null, (get, set, eventIds) => {
+	const remaining = get(internalUserEventQueueAtom)?.filter((event) => !eventIds.includes(event.eventId));
+	set(internalUserEventQueueAtom, remaining);
+});
+const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);
+const createResponsePayload = ({ userEvents, generationParams }) => {
+	const atomStore = getAtomStore();
+	const context = atomStore.get(appDetailsAtom);
+	const featureFlags = atomStore.get(featureFlagServiceAtom).getFeatureFlags();
+	return {
+		id: v4(),
+		context,
+		userEvents,
+		featureFlags,
+		generationParams
+	};
+};
+
+//#endregion
+//#region src/atoms/chat/replies.ts
+const handleReplyAtom = atom(null, (get, set, { message, userTyped }) => {
+	if (message.type !== MessageType.QueryTyped) return;
+	const queryTyped = message.metadata.content;
+	set(replyEventCategoryAtom, UserEventCategory.QueryTyped);
+	set(userQueryAtom, queryTyped);
+	set(messagesAtom, [...get(messagesAtom), [message]]);
+	set(userHasRepliedAtom, true);
+	set(queueUserEventAtom, {
+		eventId: message.id,
+		createdAt: message.createdAt,
+		category: UserEventCategory.QueryTyped,
+		attributes: { query: queryTyped }
+	});
+	AmplitudeAdapter.trackEvent({
+		eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+		eventProps: {
+			message_id: message.id,
+			message_role: message.role,
+			message_type: message.type,
+			message_metadata: {
+				content: AmplitudeAdapter.amplitudeSafeString(message?.metadata?.content),
+				created_at: message.createdAt,
+				user_typed: userTyped
+			}
+		},
+		alsoSendToGoogleAnalytics: true
+	});
+});
+
+//#endregion
+//#region src/atoms/chat/performanceMetrics.ts
+const APP_INITIAL_START_TIME_KEY = "spiffy-app-initial-start-time";
+const PAGE_LOAD_OFFSET_TIME_KEY = "spiffy-page-load-offset-time";
+/**
+* The different performance metrics that can be logged. All times are relative to the
+* initial start time of the app and are stored in milliseconds.
+*/
+let PerfMetricsEvents = /* @__PURE__ */ function(PerfMetricsEvents$1) {
+	PerfMetricsEvents$1["PageLoadOffset"] = "page_load_offset_ms";
+	PerfMetricsEvents$1["MainBundleLoaded"] = "main_bundle_loaded_ms";
+	PerfMetricsEvents$1["OrgConfigLoadStarted"] = "org_config_load_started_ms";
+	PerfMetricsEvents$1["OrgConfigLoadEnded"] = "org_config_load_ended_ms";
+	PerfMetricsEvents$1["FirstResponseStarted"] = "first_response_started_ms";
+	PerfMetricsEvents$1["FirstResponseCompleted"] = "first_response_completed_ms";
+	PerfMetricsEvents$1["FirstSuggestionsStarted"] = "first_suggestions_started_ms";
+	PerfMetricsEvents$1["FirstSuggestionsCompleted"] = "first_suggestions_completed_ms";
+	PerfMetricsEvents$1["EmbeddedWidgetRendered"] = "embedded_widget_rendered_ms";
+	PerfMetricsEvents$1["FloatingButtonRendered"] = "floating_button_rendered_ms";
+	PerfMetricsEvents$1["TopSuggestionsBarRendered"] = "top_suggestions_bar_rendered_ms";
+	PerfMetricsEvents$1["BottomSuggestionsBarRendered"] = "bottom_suggestions_bar_rendered_ms";
+	PerfMetricsEvents$1["SearchPromptRendered"] = "search_prompt_rendered_ms";
+	return PerfMetricsEvents$1;
+}({});
+const internalPerfMetricsAtom = atom(/* @__PURE__ */ new Map());
+const appInitialStartTimeMsAtom = atomWithStorage(APP_INITIAL_START_TIME_KEY, sessionStorage.getItem(APP_INITIAL_START_TIME_KEY) ?? void 0, sessionStorageUtil, { getOnInit: true });
+const pageLoadOffsetTimeAtom = atomWithStorage(PAGE_LOAD_OFFSET_TIME_KEY, sessionStorage.getItem(PAGE_LOAD_OFFSET_TIME_KEY) ?? void 0, sessionStorageUtil, { getOnInit: true });
+/**
+* Resets the performance metrics atom to an empty map. This should be called after the performance
+* metrics have been reported to amplitude. On SPA, it ensures that we can still capture metrics as
+* the user navigates around the app (although there is more work to be done to fully enable this).
+* On non-SPA, it ensures that previously captured metrics are not reported again.
+*/
+const resetPerformanceMetricsAtom = () => {
+	getAtomStore().set(internalPerfMetricsAtom, /* @__PURE__ */ new Map());
+};
+const performanceMetricsAtom = atom((get) => get(internalPerfMetricsAtom));
+const hasReportedPerformanceMetricsAtom = atom(false);
+/**
+* Logs a performance metric by capturing the delta between the initial app start time
+* and the current time. If the metric has already been logged, it will not be logged again.
+*
+* @param value The performance metric name to log.
+*/
+const logPerfMetricAtom = atom(null, (get, set, value) => {
+	const initialTimeStorageValue = get(appInitialStartTimeMsAtom);
+	const initialTimeMs = initialTimeStorageValue ? parseInt(initialTimeStorageValue, 10) : void 0;
+	if (initialTimeMs == null) {
+		logger_default.logWarn(`[spiffy-ai] No initial app start time found. Skipping...`, void 0);
+		return;
+	}
+	const currentPerfMetrics = get(internalPerfMetricsAtom);
+	if (currentPerfMetrics.has(value)) return;
+	const deltaMs = Date.now() - initialTimeMs;
+	currentPerfMetrics.set(value, deltaMs);
+	set(internalPerfMetricsAtom, currentPerfMetrics);
+});
+
+//#endregion
+//#region src/atoms/chat/form.ts
+const handleFormSubmittedAtom = atom(null, (_, set, form) => {
+	set(replyEventCategoryAtom, UserEventCategory.FormSubmitted);
+	set(formSubmitAtom, form);
+	const formUserEvent = {
+		eventId: v4(),
+		category: UserEventCategory.FormSubmitted,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		attributes: form
+	};
+	set(queueUserEventAtom, formUserEvent);
+});
+
+//#endregion
+//#region src/atoms/chat/suggestions.ts
+const handleSuggestionAtom = atom(null, (get, set, suggestion) => {
+	const newMessage = {
+		id: suggestion.id,
+		role: MessageRole.User,
+		type: MessageType.SuggestionClicked,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata: {
+			suggestionId: suggestion.id,
+			suggestionContent: suggestion.content
+		}
+	};
+	set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);
+	set(suggestionAtom, suggestion);
+	set(messagesAtom, [...get(messagesAtom), [newMessage]]);
+	set(userHasRepliedAtom, true);
+	set(queueUserEventAtom, {
+		eventId: suggestion.id,
+		category: UserEventCategory.SuggestionClicked,
+		createdAt: newMessage.createdAt,
+		attributes: { suggestionId: suggestion.id }
+	});
+});
+
+//#endregion
+//#region src/atoms/chat/lastMessage.ts
+const lastAssistantMessageAtom = atom((get) => {
+	const messages = get(messagesAtom);
+	const userHasReplied = get(userHasRepliedAtom);
+	if (messages.length > 0 && !userHasReplied) return messages[messages.length - 1];
+	return null;
+});
+
+//#endregion
+//#region src/atoms/chat/renderedWidgetRefs.ts
+const internalWidgetArrayAtom = atom([]);
+const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));
+/**
+* This function call is used to create a list of the Spiffy widgets
+* that are rendering on the page.
+*
+* It is used by the FloatingButton widget to slide out of view when it
+* overlaps with another Spiffy widget.
+*
+* The spiffy widgets should be added to the this array for the floating button
+* to know about them.
+*
+* Today the "SuggestionBar" widget is not added, but the other widgets are.
+*
+*/
+const addWidget = (ref, idx) => {
+	const atomStore = getAtomStore();
+	const val = atomStore.get(internalWidgetArrayAtom);
+	const insertIdx = idx ?? val.length;
+	val[insertIdx] = ref;
+	atomStore.set(internalWidgetArrayAtom, val);
+};
+
+//#endregion
+//#region src/atoms/chat/index.ts
+const chatAtom = atom((get) => ({
+	userHasReplied: get(userHasRepliedAtom),
+	replyEventCategory: get(replyEventCategoryAtom),
+	userQuery: get(userQueryAtom),
+	suggestion: get(suggestionAtom),
+	askQuestionBtnClicked: get(askQuestionBtnClickedAtom),
+	messages: get(messagesAtom),
+	userEvents: get(userEventsAtom),
+	suggestions: get(suggestionsAtom),
+	suggestionsLoading: get(suggestionsLoadingAtom),
+	responseStreaming: get(responseStreamingAtom),
+	isOpen: get(chatIsOpenAtom),
+	onToggle: get(chatOnToggleAtom)
+}));
+
+//#endregion
+//#region src/atoms/org/orgAnalyticsConfig.ts
+const internalOrgAnalyticsConfigAtom = atom(void 0);
+const orgAnalyticsConfigAtom = atom((get) => get(internalOrgAnalyticsConfigAtom), (_, set, value) => {
+	set(internalOrgAnalyticsConfigAtom, value);
+});
+const orgAnalyticsAmplitudeConfigAtom = atom((get) => get(orgAnalyticsConfigAtom)?.amplitude);
+const orgAnalyticsCustomerServiceConfigAtom = atom((get) => get(orgAnalyticsConfigAtom)?.customerService);
+const orgAnalyticsGoogleAnalyticsConfigAtom = atom((get) => get(orgAnalyticsConfigAtom)?.googleAnalytics);
+
+//#endregion
+//#region src/atoms/org/graphqlConfig.ts
+const internalGraphQLColorsConfigAtom = atom(void 0);
+const internalGraphQLFrontendConfigAtom = atom(void 0);
+const colorsConfigAtom = atom(async (get) => {
+	const colors = get(internalGraphQLColorsConfigAtom);
+	return {
+		...(await getOrgInfo(get(orgShortNameAtom))).orgColors(),
+		...colors
+	};
+}, (_, set, value) => {
+	set(internalGraphQLColorsConfigAtom, value);
+});
+const frontendConfigAtom = atom((get) => get(internalGraphQLFrontendConfigAtom), (_, set, value) => {
+	set(internalGraphQLFrontendConfigAtom, value);
+});
+
+//#endregion
+//#region src/atoms/org/orgUIConfig.ts
+const getCustomerServiceIntegrationMode = ({ integrationMode, isNewFeatureEnabled }) => {
+	if (integrationMode !== CustomerServiceIntegrationMode.full) return integrationMode;
+	return isNewFeatureEnabled ? integrationMode : CustomerServiceIntegrationMode.simple;
+};
+const internalOrgUIConfigAtom = atom(void 0);
+const orgUIConfigAtom = atom((get) => {
+	const orgUIConfig = get(internalOrgUIConfigAtom);
+	if (orgUIConfig) return orgUIConfig;
+	throw new Error("OrgUIConfig is referenced before it is set");
+}, (_, set, value) => {
+	set(internalOrgUIConfigAtom, value);
+});
+const getOrgUIConfig = async (graphqlOrgUIConfig, graphqlMerchantOverrideCss) => {
+	const atomStore = getAtomStore();
+	const orgShortName = atomStore.get(orgShortNameAtom);
+	const localOrgUIConfig = (await getOrgInfo(orgShortName)).orgUIConfig() ?? {};
+	const featureFlagService = atomStore.get(featureFlagServiceAtom);
+	const isNewFeatureEnabled = featureFlagService.isFeatureGateEnabled(FeatureGates.IsNewFeatureEnabled);
+	const enableWatermark = featureFlagService.isFeatureGateEnabled(FeatureGates.IsWatermarkEnabled);
+	const userQueryAwaysEnabled = featureFlagService.isFeatureGateEnabled(FeatureGates.IsUserQueryAlwaysEnabled);
+	const isGraphQLUIConfigsEnabled = featureFlagService.isFeatureGateEnabled(FeatureGates.IsGraphQLUIConfigsEnabled);
+	const isGraphQLComponentConfigsEnabled = featureFlagService.isFeatureGateEnabled(FeatureGates.IsGraphQLComponentConfigsEnabled);
+	let orgUIConfig = { ...localOrgUIConfig };
+	if (isGraphQLUIConfigsEnabled && graphqlMerchantOverrideCss) orgUIConfig = {
+		...orgUIConfig,
+		merchantOverrideCss: graphqlMerchantOverrideCss
+	};
+	if (isGraphQLComponentConfigsEnabled && graphqlOrgUIConfig) orgUIConfig = {
+		...orgUIConfig,
+		...graphqlOrgUIConfig
+	};
+	logger_default.logInfo("[spiffy-ai] Feature gate enableWatermark check", {
+		enableWatermark,
+		floatingChatConfig: orgUIConfig.floatingChatConfig
+	});
+	const updatedOrgUIConfig = {
+		...orgUIConfig,
+		conversationalSearch: orgUIConfig.conversationalSearch ? {
+			...orgUIConfig.conversationalSearch,
+			enabled: isNewFeatureEnabled
+		} : void 0,
+		customerServiceIntegration: {
+			...orgUIConfig.customerServiceIntegration,
+			integrationMode: getCustomerServiceIntegrationMode({
+				isNewFeatureEnabled,
+				integrationMode: orgUIConfig.customerServiceIntegration?.integrationMode ?? CustomerServiceIntegrationMode.none
+			})
+		},
+		floatingChatConfig: {
+			...orgUIConfig.floatingChatConfig,
+			enableWatermark: orgUIConfig.floatingChatConfig?.enableWatermark && enableWatermark,
+			userQueryInputEnabled: orgUIConfig.floatingChatConfig?.userQueryInputEnabled || userQueryAwaysEnabled
+		}
+	};
+	atomStore.set(orgUIConfigAtom, updatedOrgUIConfig);
+};
+const orgCustomerServiceConfig = atom((get) => get(orgUIConfigAtom).customerServiceIntegration);
+const orgCustomerServiceService = atom((get) => {
+	const { provider } = get(orgCustomerServiceConfig);
+	return findCustomerServiceImpl(provider);
+});
+
+//#endregion
+//#region src/atoms/org/org.ts
+const internalApiKeyAtom = atom(void 0);
+const internalEndpointURLAtom = atom(void 0);
+const internalSourceAtom = atom(EnvironmentService.getContextSource());
+const getApiKeyEnvVar = (shortName) => `VITE_${shortName.replace(/-/g, "_").toUpperCase()}_API_KEY`;
+const apiKeyAtom = atom((get) => {
+	const apiKey = get(internalApiKeyAtom);
+	if (apiKey) return apiKey;
+	const { orgLevelApiKey, orgShortName } = useEnviveConfig();
+	if (orgLevelApiKey) return orgLevelApiKey;
+	if (window._spiffy?.publicKey && typeof window._spiffy.publicKey === "string") return window._spiffy.publicKey;
+	if (!orgShortName) throw new Error("[spiffy-ai] orgShortName is required but is not set");
+	throw new Error(`[spiffy-ai]: apiKey is missing`);
+}, (_, set, newVal) => {
+	set(internalApiKeyAtom, newVal);
+});
+const endpointURLAtom = atom((get) => get(internalEndpointURLAtom) ?? EnvironmentService.getApiEndpoint(), (_, set, newVal) => {
+	set(internalEndpointURLAtom, newVal);
+});
+const sourceAtom = atom((get) => get(internalSourceAtom), (_, set, newVal) => {
+	set(internalSourceAtom, newVal);
+});
+const orgConfigStorageUtil = createJSONStorage(() => sessionStorage);
+const storedOrgConfigAtom = atomWithStorage("spiffy-org-config", void 0, orgConfigStorageUtil, { getOnInit: true });
+const internalFeatureFlagServiceAtom = atom(void 0);
+const internalOrgConfigAtom = atom(void 0);
+const internalOrgDomainAtom = atom(void 0);
+const internalOrgIdAtom = atom(void 0);
+const internalOrgShortNameAtom = atom(void 0);
+const featureFlagServiceAtom = atom((get) => {
+	const featureFlagService = get(internalFeatureFlagServiceAtom);
+	if (featureFlagService) return featureFlagService;
+	const orgConfig = get(internalOrgConfigAtom);
+	if (orgConfig) return new FeatureFlagService(orgConfig.gates);
+	throw new Error("FeatureFlagService is referenced before it is set");
+}, (_, set, value) => {
+	set(internalFeatureFlagServiceAtom, value);
+});
+const orgConfigAtom = atom((get) => {
+	const orgConfig = get(internalOrgConfigAtom);
+	if (orgConfig) return orgConfig;
+	throw new Error("OrgConfig is referenced before it is set");
+}, (_, set, value) => {
+	set(internalOrgConfigAtom, value);
+});
+const orgShortNameAtom = atom((get) => {
+	const orgShortName = get(internalOrgShortNameAtom);
+	if (orgShortName) return orgShortName;
+	throw new Error("Org short name is referenced before it is set");
+}, (_, set, value) => {
+	set(internalOrgShortNameAtom, value);
+});
+const orgDomainAtom = atom((get) => {
+	const orgDomain = get(internalOrgDomainAtom);
+	if (orgDomain) return orgDomain;
+	throw new Error("Org domain is referenced before it is set");
+}, (_, set, value) => {
+	set(internalOrgDomainAtom, value);
+});
+const orgIdAtom = atom((get) => {
+	const orgId = get(internalOrgIdAtom);
+	if (orgId) return orgId;
+	throw new Error("Org id is referenced before it is set");
+}, (_, set, value) => {
+	set(internalOrgIdAtom, value);
+});
+const resetStoredOrgConfigAtom = () => {
+	getAtomStore().set(storedOrgConfigAtom, {});
+};
+const getGraphQLConfig = async (atomStore) => {
+	const { colorsConfig, frontendConfig } = await GraphQLClient.getColorsAndFrontendConfig() ?? {};
+	const rawFrontendConfig = atomStore.get(frontendConfigAtom);
+	atomStore.set(colorsConfigAtom, colorsConfig);
+	atomStore.set(frontendConfigAtom, {
+		...rawFrontendConfig,
+		pageVariants: frontendConfig?.pageVariants,
+		mountingConfigs: frontendConfig?.mountingConfigs,
+		widgetConfigs: frontendConfig?.widgetConfigs
+	});
+	await getOrgUIConfig(frontendConfig?.uiConfigs, frontendConfig?.merchantOverrideCss);
+};
+/**
+* This function is used to return an orgConfig corresponding to a given API key
+*
+* @param apiKeyOverride an optional new api key to override the current key stored in apiKeyAtom
+*
+* @returns The OrgAnalyticsConfig object or throws an error if the config was not successfully retrieved
+*/
+const getAsyncOrgConfig = async (apiKeyOverride) => {
+	const atomStore = getAtomStore();
+	const apiKey = apiKeyOverride ?? atomStore.get(apiKeyAtom);
+	atomStore.set(apiKeyAtom, apiKey);
+	atomStore.set(endpointURLAtom, EnvironmentService.getApiEndpoint());
+	atomStore.set(sourceAtom, EnvironmentService.getContextSource());
+	atomStore.set(logPerfMetricAtom, PerfMetricsEvents.OrgConfigLoadStarted);
+	const maybeOrgConfigByApiKey = atomStore.get(storedOrgConfigAtom);
+	let maybeOrgConfig = maybeOrgConfigByApiKey?.[apiKey];
+	if (!maybeOrgConfig) {
+		const userId = UserIdentityService.getUserIdOrDefault();
+		maybeOrgConfig = await api_default.getOrgConfig(userId);
+	}
+	if (!maybeOrgConfig) throw new Error("[spiffy-ai] Org config is not defined but is required");
+	const latestConfig = maybeOrgConfig.configs?.find((config) => config.isLatest);
+	if (!latestConfig) throw new Error("[spiffy-ai] no latest org config is found");
+	const orgConfig = {
+		...maybeOrgConfig,
+		configs: [{ ...latestConfig }]
+	};
+	if (!orgConfig.org) throw new Error("[spiffy-ai] orgConfig.org is not defined but is required");
+	atomStore.set(logPerfMetricAtom, PerfMetricsEvents.OrgConfigLoadEnded);
+	atomStore.set(orgShortNameAtom, orgConfig.org.org.shortName);
+	atomStore.set(orgDomainAtom, orgConfig.org.org.domain);
+	atomStore.set(orgIdAtom, orgConfig.org.org.id);
+	atomStore.set(storedOrgConfigAtom, {
+		...maybeOrgConfigByApiKey,
+		[apiKey]: orgConfig
+	});
+	atomStore.set(orgConfigAtom, orgConfig);
+	atomStore.set(orgAnalyticsConfigAtom, { ...latestConfig.config });
+	atomStore.set(featureFlagServiceAtom, new FeatureFlagService(orgConfig.gates));
+	await getGraphQLConfig(atomStore);
+	return orgConfig;
+};
+
+//#endregion
+//#region src/adapters/spiffy/commerce/graphql.ts
+const configVersion = () => getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || "deployed";
+const colorsAndFrontendConfigQuery = () => `
+  query ($version: String = "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        frontend { values }
+        colors { values }
+      }
+    }
+  }
+`;
+var GraphQLClient = class GraphQLClient {
+	static {
+		this.setInstance = (apiKey, basePath) => {
+			GraphQLClient.instance = new GraphQLClient(apiKey, basePath);
+		};
+	}
+	static {
+		this.getInstance = () => {
+			if (!GraphQLClient.instance) {
+				const apiKey = getAtomStore().get(apiKeyAtom);
+				GraphQLClient.instance = new GraphQLClient(apiKey, EnvironmentService.getApiEndpoint());
+			}
+			return GraphQLClient.instance;
+		};
+	}
+	constructor(apiKey, basePath) {
+		this.apiKey = apiKey;
+		this.basePath = basePath;
+	}
+	async executeQuery(query, variables) {
+		const response = await fetch(`${this.basePath}/v1/graphql`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this.apiKey}`
+			},
+			body: JSON.stringify({
+				query,
+				variables
+			})
+		});
+		if (!response.ok) throw new Error(`GraphQL request failed: ${response.statusText}`);
+		const result = await response.json();
+		if (result.errors) throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+		return result.data;
+	}
+	static {
+		this.getOrgId = async () => {
+			const query = getMerchantOrgIdQuery;
+			if (!query) throw new Error("Org id query is not defined");
+			const response = await GraphQLClient.getInstance().executeQuery(query);
+			return validateGraphQLOrgId(response.me.org?.id);
+		};
+	}
+	static {
+		this.getColorsAndFrontendConfig = async () => {
+			try {
+				const query = colorsAndFrontendConfigQuery();
+				if (!query) throw new Error("Colors and frontend config query is not defined");
+				const response = await GraphQLClient.getInstance().executeQuery(query);
+				return {
+					colorsConfig: validateGraphQLColorsConfig(response.me.getProductsConfigByVersion?.colors?.values),
+					frontendConfig: validateGraphQLFrontendConfig(response.me.getProductsConfigByVersion?.frontend?.values)
+				};
+			} catch (err) {
+				logger_default.logError("Error fetching graphql colors and frontend config", err);
+				return {
+					colorsConfig: void 0,
+					frontendConfig: void 0
+				};
+			}
+		};
+	}
+	static {
+		this.getFrontendConfig = async () => {
+			try {
+				const query = getMerchantFrontendConfigQuery();
+				if (!query) throw new Error("Frontend config query is not defined");
+				const response = await GraphQLClient.getInstance().executeQuery(query);
+				if (!response.me.getProductsConfigByVersion?.frontend) throw new Error("No frontend config found");
+				return validateGraphQLFrontendConfig(response.me.getProductsConfigByVersion.frontend.values);
+			} catch (err) {
+				logger_default.logError("Error fetching graphql frontend config", err);
+				return;
+			}
+		};
+	}
+	static {
+		this.getColors = async () => {
+			try {
+				const query = getMerchantColorsQuery();
+				if (!query) throw new Error("Colors query is not defined");
+				const response = await GraphQLClient.getInstance().executeQuery(query);
+				if (!response.me.getProductsConfigByVersion?.colors) throw new Error("No colors config found");
+				return isGraphQLColorsConfig(response.me.getProductsConfigByVersion.colors.values) ? response.me.getProductsConfigByVersion.colors.values : void 0;
+			} catch (err) {
+				logger_default.logError("Error fetching graphql colors config", err);
+				return;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantFrontendConfigQuery.ts
+const getMerchantFrontendConfigQuery = () => `
+  query ($version: "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        frontend {
+          values
+        }
+      }
+    }
+  }
+`;
+
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantColorsQuery.ts
+const getMerchantColorsQuery = () => `
+  query ($version: "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        colors {
+          values
+        }
+      }
+    }
+  }
+`;
+
+//#endregion
+//#region src/application/models/guards/isBaseEcommerceEvent.ts
+/**
+* Checks if an event is a base Google Analytics ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a base ecommerce event, false otherwise.
+*/
+const isBaseEcommerceEvent = (data) => data != null && typeof data === "object" && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "event" in data && typeof data.event === "string";
+
+//#endregion
+//#region src/application/models/guards/isGA4EcommerceEvent.ts
+/**
+* Checks if an event is a Google Analytics 4 ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a GA4 ecommerce event, false otherwise.
+*/
+const isGA4EcommerceEvent = (data) => typeof data === "object" && data != null && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "items" in data.ecommerce && Array.isArray(data.ecommerce.items);
+
+//#endregion
+//#region src/application/models/guards/isLegacyUAEcommerceEvent.ts
+/**
+* Checks if an event is a legacy Universal Analytics ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a legacy UA ecommerce event, false otherwise.
+*/
+const isLegacyUAEcommerceEvent = (data) => data != null && typeof data === "object" && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "add" in data.ecommerce && typeof data.ecommerce.add === "object";
+
+//#endregion
+//#region src/application/models/guards/isMobilePLPChatPlacementParameter.ts
+const isMobilePLPChatPlacementParameter = (value) => value != null && typeof value === "object" && "row_index" in value && typeof value.row_index === "number";
+
+//#endregion
+//#region src/application/models/guards/isSpanxTakeAQuizCtaParameter.ts
+const isSpanxTakeAQuizCtaParameter = (value) => value != null && typeof value === "object" && "text" in value && typeof value.text === "string";
+
+//#endregion
+//#region src/application/models/guards/isVariantInfo.ts
+const isPDPVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "pdp" && "productId" in variantInfo && typeof variantInfo.productId === "string";
+const isPLPVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "plp" && "plpId" in variantInfo && typeof variantInfo.plpId === "string";
+const isPageVisitVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "page_visit" && "url" in variantInfo && typeof variantInfo.url === "string" && "pageVisitCategory" in variantInfo && Object.values(PageVisitCategory).includes(variantInfo.pageVisitCategory);
+/**
+* Type guard to check if an object is a valid VariantInfo.
+*
+* @param variantInfo - The unknown object to check.
+*
+* @returns True if the data is a valid VariantInfo object, false otherwise.
+*/
+const isVariantInfo = (variantInfo) => variantInfo != null && typeof variantInfo === "object" && "variantId" in variantInfo && (isPDPVariantInfo(variantInfo) || isPLPVariantInfo(variantInfo) || isPageVisitVariantInfo(variantInfo));
+
+//#endregion
+//#region src/application/models/guards/api/isApiFormResponse.ts
+/**
+* Type guard to check if the provided data has the all of the properties (with the correct types) of
+* a FormResponseAttribute
+*
+* @param data - The data to check
+*
+* @returns true if the data has the correct properties, false otherwise
+*/
+const isApiFormResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logError("isApiFormResponseAttributes: data is null or not an object", void 0, { data });
+		return false;
+	}
+	if ("form_category" in data && typeof data.form_category !== "object") {
+		logger_default.logError("isApiFormResponseAttributes: form_category is not an object", void 0, { data });
+		return false;
+	}
+	if ("form_category" in data && typeof data.form_category === "object") {
+		if (!hasPropertyOfType(data.form_category, "form_type", "string") || !Object.values(FormType).includes(data.form_category.form_type)) {
+			logger_default.logError("isApiFormResponseAttributes: form_type is missing or not a valid form type", void 0, { data });
+			return false;
+		}
+	}
+	if (!hasPropertyOfType(data, "schema", "object")) {
+		logger_default.logError("isApiFormResponseAttributes: schema is missing or not an object", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data.schema, "properties", "object")) {
+		logger_default.logError("isApiFormResponseAttributes: schema.properties is missing or not an object", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data.schema, "required", "array")) {
+		logger_default.logError("isApiFormResponseAttributes: schema.required is missing or not an array", void 0, { data });
+		return false;
+	}
+	if (!data.schema.required.every((key) => typeof key === "string" && key in data.schema.properties)) {
+		logger_default.logError("isApiFormResponseAttributes: schema.required contains invalid property keys", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrderResponseAttributes.ts
+const isApiOrderItemInfo = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logError("OrderItemInfo must be an object", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "order_item_id", "string")) {
+		logger_default.logError("OrderItemInfo must have an order_item_id property", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "item_title", "string")) {
+		logger_default.logError("OrderItemInfo must have an item_title property", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "item_price", "number")) {
+		logger_default.logError("OrderItemInfo must have an item_price property", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "item_quantity", "number")) {
+		logger_default.logError("OrderItemInfo must have an item_quantity property", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "image", "string", true)) {
+		logger_default.logError("OrderItemInfo.image must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "fulfillment_display_status", "string", true)) {
+		logger_default.logError("OrderItemInfo.fulfillment_display_status must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "tracking_url", "string", true)) {
+		logger_default.logError("OrderItemInfo.tracking_url must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "delivered_at", "string", true)) {
+		logger_default.logError("OrderItemInfo.delivered_at must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "estimated_delivery_at", "string", true)) {
+		logger_default.logError("OrderItemInfo.estimated_delivery_at must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "in_transit_at", "string", true)) {
+		logger_default.logError("OrderItemInfo.in_transit_at must be a string or null", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrderResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logError("Order response attributes must be an object", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "created_at", "string")) {
+		logger_default.logError("Order response attributes must have a created_at property and have type string", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "latest_event_date", "string")) {
+		logger_default.logError("Order response attributes must have a latest_event_date property and have type string", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "line_items", "array") || !data.line_items.every((item) => isApiOrderItemInfo(item))) {
+		logger_default.logError("Order response attributes must have a line_items property with at least one order item", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "order_id", "string")) {
+		logger_default.logError("Order response attributes must have an order_id property and have type string", void 0, { data });
+		return false;
+	}
+	if (!hasPropertyOfType(data, "order_number", "string")) {
+		logger_default.logError("Order response attributes must have an order_number property and have type string", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrganizationConfig.ts
+const isApiOrgAnalyticsConfigAmplitude = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: data is not an object", data);
+		return false;
+	}
+	if (!("session_replay_enabled" in data) || typeof data.session_replay_enabled !== "boolean") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_enabled is not a boolean", data);
+		return false;
+	}
+	if (!("session_replay_sample_rate" in data) || typeof data.session_replay_sample_rate !== "number") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_sample_rate is not a number", data);
+		return false;
+	}
+	if (!("tracking_enabled" in data) || typeof data.tracking_enabled !== "boolean") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: tracking_enabled is not a boolean", data);
+		return false;
+	}
+	return true;
+};
+const isApiOrgAnalyticsConfigCustomerService = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: data is not an object", data);
+		return false;
+	}
+	if (!("provider" in data) || typeof data.provider !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: provider is not a string", data);
+		return false;
+	}
+	return true;
+};
+const isApiOrgAnalyticsConfigGoogleAnalytics = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: data is not an object", data);
+		return false;
+	}
+	if (!("measurement_id" in data) || typeof data.measurement_id !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: measurement_id is not a string", data);
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrgAnalyticsConfig = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: data is not an object", data);
+		return false;
+	}
+	if ("amplitude" in data && !isApiOrgAnalyticsConfigAmplitude(data.amplitude)) {
+		logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: amplitude is not an object", data);
+		return false;
+	}
+	if ("customer_service" in data && !isApiOrgAnalyticsConfigCustomerService(data.customer_service)) {
+		logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: customer_service is not an object", data);
+		return false;
+	}
+	if ("google_analytics" in data && !isApiOrgAnalyticsConfigGoogleAnalytics(data.google_analytics)) {
+		logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: google_analytics is not an object", data);
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrganizationConfig = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: data is not an object", data);
+		return false;
+	}
+	if (!("created_at" in data)) {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: created_at is not defined", data);
+		return false;
+	}
+	if (!("namespace" in data) || typeof data.namespace !== "string") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: namespace is not a string", data);
+		return false;
+	}
+	if (!("is_latest" in data) || typeof data.is_latest !== "boolean") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: is_latest is not a boolean", data);
+		return false;
+	}
+	if (!("version" in data) || typeof data.version !== "string") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: version is not a string", data);
+		return false;
+	}
+	if (!("updated_at" in data)) {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: updated_at is not defined", data);
+		return false;
+	}
+	if (!("config" in data) || typeof data.config !== "object" || !isApiOrgAnalyticsConfig(data.config)) {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: config is not an object", data);
+		return false;
+	}
+	if ("organization_id" in data && typeof data.organization_id !== "string") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: organization_id is not a string", data);
+		return false;
+	}
+	if ("id" in data && typeof data.id !== "string") {
+		logger_default.logDebug("[spiffy-ai] isOrgConfig: id is not a string", data);
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrgConfigResults.ts
+const isApiOrgConfigExperiment = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: data is not an object", void 0, { data });
+		return false;
+	}
+	if ("group" in data && typeof data.group !== "string" && data.group !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: group is not a string or undefined", void 0, { data });
+		return false;
+	}
+	if ("group_name" in data && typeof data.group_name !== "string" && data.group_name !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: group_name is not a string", void 0, { data });
+		return false;
+	}
+	if ("name" in data && typeof data.name !== "string" && data.name !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: name is not a string", void 0, { data });
+		return false;
+	}
+	if ("rule_id" in data && typeof data.rule_id !== "string" && data.rule_id !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: rule_id is not a string", void 0, { data });
+		return false;
+	}
+	if ("value" in data && typeof data.value !== "object" && data.value !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: value is not an object", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrgConfigFeatureGate = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: data is not an object", void 0, { data });
+		return false;
+	}
+	if ("name" in data && typeof data.name !== "string" && data.name !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: name is not a string", void 0, { data });
+		return false;
+	}
+	if ("rule_id" in data && typeof data.rule_id !== "string" && data.rule_id !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: rule_id is not a string", void 0, { data });
+		return false;
+	}
+	if ("value" in data && typeof data.value !== "boolean" && data.value !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: value is not a boolean", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrganization = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("id" in data) || typeof data.id !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: id is not a string", void 0, { data });
+		return false;
+	}
+	if (!("display_name" in data) || typeof data.display_name !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: display_name is not a string", void 0, { data });
+		return false;
+	}
+	if (!("domain" in data) || typeof data.domain !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: domain is not a string", void 0, { data });
+		return false;
+	}
+	if (!("short_name" in data) || typeof data.short_name !== "string") {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: short_name is not a string", void 0, { data });
+		return false;
+	}
+	if (!("status" in data) || !Object.values(OrganizationStatusEnum).includes(data.status)) {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: status is not a valid OrganizationStatusEnum value", void 0, { data });
+		return false;
+	}
+	if ("created_at" in data && !(data.created_at instanceof Date) && typeof data.created_at !== "string" && data.created_at !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: created_at is not a Date", void 0, { data });
+		return false;
+	}
+	if ("updated_at" in data && !(data.updated_at instanceof Date) && typeof data.updated_at !== "string" && data.updated_at !== void 0) {
+		logger_default.logDebug("[spiffy-ai] isApiOrganization: updated_at is not a Date", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrgConfigOrganizationSettings = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigOrganizationSettings: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("org" in data) || !isApiOrganization(data.org)) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigOrganizationSettings: org is not an object", void 0, { data });
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrgConfigResults = (data) => {
+	if (data == null || typeof data !== "object") {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("configs" in data) || !Array.isArray(data.configs) || !data.configs.every((config) => isApiOrganizationConfig(config))) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: configs is not an array", void 0, { data });
+		return false;
+	}
+	if ("experiments" in data && data.experiments !== void 0 && (!Array.isArray(data.experiments) || !data.experiments.every((exp) => isApiOrgConfigExperiment(exp)))) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: experiments is not an array or contains invalid items", void 0, { data });
+		return false;
+	}
+	if (!("gates" in data) || !Array.isArray(data.gates) || !data.gates.every((gate) => isApiOrgConfigFeatureGate(gate))) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: gates is not an array or contains invalid items", void 0, { data });
+		return false;
+	}
+	if (!("org" in data) || !isApiOrgConfigOrganizationSettings(data.org)) {
+		logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: org is not an object or has invalid fields", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiPageResponseAttributes.ts
+const isApiPageResponseAttributes = (obj) => {
+	if (obj == null || typeof obj !== "object") return false;
+	if ("title" in obj && obj.title != null && typeof obj.title !== "string") return false;
+	if ("description" in obj && typeof obj.description !== "string") return false;
+	if ("url" in obj && typeof obj.url !== "string") return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiProductSearchFilterAttributes.ts
+const isApiProductSearchFilterResponseAttributes = (attributes) => {
+	if (attributes == null || typeof attributes !== "object") return false;
+	if ("filter_name" in attributes && typeof attributes.filter_name !== "string") return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue.ts
+/**
+* Converts a string to a FulfillmentDisplayStatus enum value.
+*
+* @param status - The string to convert.
+*
+* @returns The FulfillmentDisplayStatus enum value or undefined if the string
+* does not map to a valid enum
+*/
+const stringToFulfillmentDisplayStatusEnumValue = (status) => {
+	switch (status) {
+		case "ATTEMPTED_DELIVERY": return FulfillmentDisplayStatus.ATTEMPTED_DELIVERY;
+		case "CANCELED": return FulfillmentDisplayStatus.CANCELED;
+		case "CONFIRMED": return FulfillmentDisplayStatus.CONFIRMED;
+		case "DELIVERED": return FulfillmentDisplayStatus.DELIVERED;
+		case "FAILURE": return FulfillmentDisplayStatus.FAILURE;
+		case "FULFILLED": return FulfillmentDisplayStatus.FULFILLED;
+		case "IN_TRANSIT": return FulfillmentDisplayStatus.IN_TRANSIT;
+		case "LABEL_PRINTED": return FulfillmentDisplayStatus.LABEL_PRINTED;
+		case "LABEL_PURCHASED": return FulfillmentDisplayStatus.LABEL_PURCHASED;
+		case "LABEL_VOIDED": return FulfillmentDisplayStatus.LABEL_VOIDED;
+		case "MARKED_AS_FULFILLED": return FulfillmentDisplayStatus.MARKED_AS_FULFILLED;
+		case "NOT_DELIVERED": return FulfillmentDisplayStatus.NOT_DELIVERED;
+		case "OUT_FOR_DELIVERY": return FulfillmentDisplayStatus.OUT_FOR_DELIVERY;
+		case "PICKED_UP": return FulfillmentDisplayStatus.PICKED_UP;
+		case "READY_FOR_PICKUP": return FulfillmentDisplayStatus.READY_FOR_PICKUP;
+		case "SUBMITTED": return FulfillmentDisplayStatus.SUBMITTED;
+		case "IN_PROGRESS": return FulfillmentDisplayStatus.IN_PROGRESS;
+		case "ON_HOLD": return FulfillmentDisplayStatus.ON_HOLD;
+		case "OPEN": return FulfillmentDisplayStatus.OPEN;
+		case "PARTIALLY_FULFILLED": return FulfillmentDisplayStatus.PARTIALLY_FULFILLED;
+		case "PENDING_FULFILLMENT": return FulfillmentDisplayStatus.PENDING_FULFILLMENT;
+		case "REQUEST_DECLINED": return FulfillmentDisplayStatus.REQUEST_DECLINED;
+		case "RESTOCKED": return FulfillmentDisplayStatus.RESTOCKED;
+		case "SCHEDULED": return FulfillmentDisplayStatus.SCHEDULED;
+		case "UNFULFILLED": return FulfillmentDisplayStatus.UNFULFILLED;
+		default: return;
+	}
+};
+
+//#endregion
+//#region src/application/models/validators/validateMobilePLPChatPlacementParameter.ts
+const validateMobilePLPChatPlacementParameter = (value) => {
+	if (!isMobilePLPChatPlacementParameter(value)) return;
+	return { rowIndex: value.row_index };
+};
+
+//#endregion
+//#region src/application/models/validators/validateOrganizationConfig.ts
+const validateOrganizationConfig = (data) => {
+	if (!isApiOrganizationConfig(data)) return;
+	return {
+		id: data.id,
+		createdAt: data.created_at.toISOString(),
+		namespace: data.namespace,
+		organizationId: data.organization_id,
+		isLatest: data.is_latest,
+		version: data.version,
+		updatedAt: data.updated_at.toISOString(),
+		config: {
+			amplitude: data.config.amplitude ? {
+				sessionReplayEnabled: data.config.amplitude.session_replay_enabled,
+				sessionReplaySampleRate: data.config.amplitude.session_replay_sample_rate,
+				trackingEnabled: data.config.amplitude.tracking_enabled
+			} : void 0,
+			customerService: data.config.customer_service ? { provider: data.config.customer_service.provider } : void 0,
+			googleAnalytics: data.config.google_analytics ? { measurementId: data.config.google_analytics.measurement_id } : void 0
+		}
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateOrgConfigResults.ts
+/**
+*
+* @param data
+* @returns
+*/
+const validateOrgConfigResults = (data) => {
+	if (!isApiOrgConfigResults(data)) return;
+	return {
+		configs: data.configs.map((config) => validateOrganizationConfig(config)).filter((config) => config != null),
+		experiments: data.experiments.map((experiment) => ({
+			group: experiment.group,
+			groupName: experiment.group_name,
+			name: experiment.name,
+			ruleId: experiment.rule_id,
+			value: experiment.value
+		})),
+		gates: data.gates.map((gate) => ({
+			groupName: gate.group_name,
+			name: gate.name,
+			ruleId: gate.rule_id,
+			value: gate.value
+		})),
+		org: {
+			org: {
+				id: data.org.org.id,
+				displayName: data.org.org.display_name,
+				domain: data.org.org.domain,
+				shortName: data.org.org.short_name,
+				status: data.org.org.status,
+				createdAt: data.org.org.created_at?.toISOString(),
+				updatedAt: data.org.org.updated_at?.toISOString()
+			},
+			settings: {}
+		}
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateResponse.ts
+const richInformationFromCommerceRichInformation = (data) => ({
+	cons: data.cons,
+	pros: data.pros,
+	reviewDate: data.review_date,
+	reviewerTitle: data.reviewer_title,
+	productFamiliarity: data.product_familiarity
+});
+const validateResponse = (data) => {
+	if (!isApiResponse(data)) return;
+	if (data.category === ResponseCategory.Text && isApiTextResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Text,
+		attributes: { content: data.attributes.content }
+	};
+	if (data.category === ResponseCategory.Product && isApiProductResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Product,
+		attributes: {
+			id: data.attributes.id,
+			description: data.attributes.description,
+			imageUrl: data.attributes.image_url,
+			imageUrls: data.attributes.image_urls,
+			title: data.attributes.title,
+			url: data.attributes.url,
+			originalPrice: data.attributes.original_price,
+			salePrice: data.attributes.sale_price,
+			averageRating: data.attributes.average_rating,
+			numberReviews: data.attributes.number_reviews,
+			metadata: data.attributes.metadata,
+			isForGrid: data.attributes.is_for_grid,
+			colors: data.attributes.colors,
+			sizes: data.attributes.sizes,
+			filters: data.attributes.filters
+		}
+	};
+	if (data.category === ResponseCategory.Review && isApiReviewResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Review,
+		attributes: {
+			id: data.attributes.id,
+			productId: data.attributes.product_id,
+			title: data.attributes.title,
+			reviewer: data.attributes.reviewer,
+			review: data.attributes.review,
+			stars: data.attributes.stars,
+			richInformation: data.attributes.rich_information ? richInformationFromCommerceRichInformation(data.attributes.rich_information) : void 0
+		}
+	};
+	if (data.category === ResponseCategory.Separator) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Separator
+	};
+	if (data.category === ResponseCategory.Page && isApiPageResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Page,
+		attributes: {
+			id: data.attributes.id,
+			title: data.attributes.title,
+			description: data.attributes.description,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === ResponseCategory.Form && isApiFormResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Form,
+		attributes: {
+			formCategory: data.attributes.form_category ? { formType: data.attributes.form_category.form_type } : void 0,
+			schema: {
+				properties: data.attributes.schema.properties,
+				required: data.attributes.schema.required.map(String)
+			}
+		}
+	};
+	if (data.category === ResponseCategory.ProductSearch && isApiProductSearchResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.ProductSearch,
+		attributes: {
+			generatedQuery: data.attributes.generated_query,
+			productCount: data.attributes.product_count
+		}
+	};
+	if (data.category === ResponseCategory.ProductSearchFilter && isApiProductSearchFilterResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.ProductSearchFilter,
+		attributes: { filterName: data.attributes.filter_name }
+	};
+	if (data.category === ResponseCategory.Order && isApiOrderResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: ResponseCategory.Order,
+		attributes: {
+			orderId: data.attributes.order_id,
+			orderNumber: data.attributes.order_number,
+			createdAt: data.attributes.created_at,
+			latestEventDate: data.attributes.latest_event_date,
+			lineItems: data.attributes.line_items.map((item) => ({
+				itemTitle: item.item_title,
+				itemPrice: item.item_price,
+				itemQuantity: item.item_quantity,
+				orderItemId: item.order_item_id,
+				image: item.image ?? void 0,
+				inTransitAt: item.in_transit_at ?? void 0,
+				deliveredAt: item.delivered_at ?? void 0,
+				estimatedDeliveryAt: item.estimated_delivery_at ?? void 0,
+				fulfillmentDisplayStatus: item.fulfillment_display_status ? stringToFulfillmentDisplayStatusEnumValue(item.fulfillment_display_status) : void 0,
+				trackingUrl: item.tracking_url ?? void 0
+			}))
+		}
+	};
+};
+
+//#endregion
+//#region src/enabled-features.ts
+var EnabledFeatures = class {
+	static {
+		this.values = void 0;
+	}
+	static async get(orgConfig, featureFlagService) {
+		if (this.values !== void 0) return this.values;
+		const isSpiffyEnabled = async (orgConfig$1, featureFlagService$1) => {
+			if (LocalStorageService.getSpiffyOnFeatureFlag() === "true") {
+				logger_default.logDebug(`[spiffy-ai] spiffy enabled by "spiffy_on" override`);
+				return true;
+			}
+			if (LocalStorageService.getSpiffyOnFeatureFlag() === "false") {
+				logger_default.logDebug(`[spiffy-ai] envive disabled by "envive_on" override`);
+				return false;
+			}
+			if (window._spiffy?.show != null && !window._spiffy.show) {
+				logger_default.logDebug(`[spiffy-ai] spiffy disabled by window._spiffy.show`);
+				return false;
+			}
+			if (!featureFlagService$1.isClientSessionEnabled()) {
+				logger_default.logDebug(`[spiffy-ai] spiffy disabled by feature flag`);
+				return false;
+			}
+			if (window._spiffy?.show != null && window._spiffy.show) {
+				logger_default.logDebug(`[spiffy-ai] spiffy enabled by window._spiffy.show`);
+				return true;
+			}
+			if ((await getOrgInfo(orgConfig$1.org.org.shortName)).alwaysEnabledMerchants) {
+				logger_default.logDebug(`[spiffy-ai] spiffy enabled by org config and feature flag`);
+				return true;
+			}
+			if (featureFlagService$1.isClientSessionEnabled()) {
+				logger_default.logDebug(`[spiffy-ai] spiffy is enabled by feature flag`);
+				return true;
+			}
+			logger_default.logDebug(`[spiffy-ai] spiffy is disabled because not all checks have passed`);
+			return false;
+		};
+		const isSalesAgentEnabled = isSpiffyEnabled;
+		this.values = {
+			envive: await isSpiffyEnabled(orgConfig, featureFlagService),
+			salesAgent: await isSalesAgentEnabled(orgConfig, featureFlagService)
+		};
+		return this.values;
+	}
+	static reset() {
+		this.values = void 0;
+	}
+};
+
+//#endregion
+//#region src/adapters/amplitude/amplitudeAdapter.ts
+let SpiffyMetricsEventName = /* @__PURE__ */ function(SpiffyMetricsEventName$1) {
+	SpiffyMetricsEventName$1["BundleLoaded"] = "Bundle Loaded";
+	SpiffyMetricsEventName$1["ChatLiveAgentBtnClick"] = "Chat Live Agent Btn Click";
+	SpiffyMetricsEventName$1["ChatFloatingButtonVisible"] = "Chat Floating Button Visible";
+	SpiffyMetricsEventName$1["ChatComponentVisible"] = "Chat Component Visible";
+	SpiffyMetricsEventName$1["ChatComponentExpanded"] = "Chat Component Expanded";
+	SpiffyMetricsEventName$1["ChatComponentCollapsed"] = "Chat Component Collapsed";
+	SpiffyMetricsEventName$1["ChatUserMessageInput"] = "Chat User Message Input";
+	SpiffyMetricsEventName$1["ChatSuggestionClicked"] = "Chat Suggestion Clicked";
+	SpiffyMetricsEventName$1["ChatAssistantResponse"] = "Chat Assistant Response";
+	SpiffyMetricsEventName$1["ProductCardClicked"] = "Product Card Clicked";
+	SpiffyMetricsEventName$1["ProductReviewCardClicked"] = "Product Review Card Clicked";
+	SpiffyMetricsEventName$1["AddToCartClicked"] = "Add to Cart Clicked";
+	SpiffyMetricsEventName$1["PromptCardClicked"] = "Prompt Card Clicked";
+	SpiffyMetricsEventName$1["SupportedEvent"] = "Supported Event";
+	SpiffyMetricsEventName$1["SearchBackToResponseClicked"] = "Search Back to Response Clicked";
+	SpiffyMetricsEventName$1["PerformanceMetrics"] = "Performance Metrics";
+	SpiffyMetricsEventName$1["SearchBarClicked"] = "Search Bar Clicked";
+	SpiffyMetricsEventName$1["OrderLookupStarted"] = "Order Lookup Started";
+	SpiffyMetricsEventName$1["OrderLookupFormSubmitted"] = "Order Lookup Form Submitted";
+	SpiffyMetricsEventName$1["SearchComponentVisible"] = "Search Component Visible";
+	SpiffyMetricsEventName$1["GlobalSearchPromptClicked"] = "Global Search Prompt Clicked";
+	SpiffyMetricsEventName$1["SearchInputStarted"] = "Search Input Started";
+	SpiffyMetricsEventName$1["SearchQuerySubmitted"] = "Search Query Submitted";
+	SpiffyMetricsEventName$1["SearchResultsViewed"] = "Search Results Viewed";
+	SpiffyMetricsEventName$1["SearchTimeToFirstClick"] = "Search Time to First Click";
+	SpiffyMetricsEventName$1["SearchZeroResultsRate"] = "Search Zero Results Rate";
+	SpiffyMetricsEventName$1["SearchFilterClicked"] = "Search Filter Clicked";
+	SpiffyMetricsEventName$1["SearchSortClicked"] = "Search Sort Clicked";
+	return SpiffyMetricsEventName$1;
+}({});
+var AmplitudeAdapter = class AmplitudeAdapter {
+	constructor(userId, orgConfig, featureFlagService, orgGaConfig) {
+		this.userId = userId;
+		this.orgConfig = orgConfig;
+		this.featureFlagService = featureFlagService;
+		this.orgGaConfig = orgGaConfig;
+		this.underlyingAmplitudeClient = void 0;
+		this.internalEventTrackingEnrichment = void 0;
+		this.eventPropsToPrefixedEventProps = (eventName, eventProps) => {
+			const prefix = eventName.toLowerCase().replace(/\s+/g, "_");
+			return Object.entries(eventProps).reduce((acc, [key, value]) => {
+				acc[`${prefix}.${key}`] = value;
+				return acc;
+			}, {});
+		};
+		this.supplementalDefaultProps = {};
+	}
+	init() {
+		this.underlyingAmplitudeClient = this.createUnderlyingClient();
+	}
+	getUnderlyingAmplitudeClient() {
+		return this.underlyingAmplitudeClient;
+	}
+	getSupplementalDefaultProps() {
+		return this.supplementalDefaultProps;
+	}
+	setSupplementalDefaultProps(supplementalDefaultProps) {
+		this.supplementalDefaultProps = supplementalDefaultProps;
+	}
+	getEventTrackingEnrichment() {
+		if (this.internalEventTrackingEnrichment !== void 0) return this.internalEventTrackingEnrichment;
+		this.internalEventTrackingEnrichment = {
+			name: "page-view-tracking-enrichment",
+			type: "enrichment",
+			setup: async () => void 0,
+			execute: async (event) => {
+				let enrichedEvent;
+				if (["[Amplitude] Page Viewed", `[Spiffy] ${SpiffyMetricsEventName.BundleLoaded}`].includes(event.event_type)) {
+					const windowProps = window._spiffy ? { ...window._spiffy } : {};
+					if (windowProps.publicKey) delete windowProps.publicKey;
+					const globalProperties = Object.entries(windowProps).reduce((acc, [key, value]) => ({
+						...acc,
+						[`globalProperties.${key}`]: `${value}`
+					}), {});
+					const enabledFeatures = await EnabledFeatures.get(this.orgConfig, this.featureFlagService);
+					const enabledFeaturesProperties = Object.entries(enabledFeatures).reduce((acc, [key, value]) => ({
+						...acc,
+						[`enabledFeatures.${key}`]: `${value}`
+					}), {});
+					const timingProperties = { "timing.enriched_at_ms": window.performance?.now() };
+					enrichedEvent = {
+						...event,
+						event_properties: {
+							...event.event_properties,
+							...this.getDefaultTrackingProps(),
+							...globalProperties,
+							...enabledFeaturesProperties,
+							...timingProperties
+						}
+					};
+				} else enrichedEvent = event;
+				EventsDispatcher.dispatch(SpiffyEvent.AMPLITUDE_EVENT, enrichedEvent);
+				return enrichedEvent;
+			}
+		};
+		return this.internalEventTrackingEnrichment;
+	}
+	amplitudeSessionReplayInit() {
+		const isEnabled = this.orgConfig.org.org.shortName === OrgShortName.UniqueVintage && this.featureFlagService.isClientSessionEnabled() && this.featureFlagService.isFeatureGateEnabled(FeatureGates.IsNewFeatureEnabled);
+		const sampleRate = 1;
+		try {
+			logger_default.logDebug(`[spiffy-ai] amplitude session-replay initializing isEnabled=${isEnabled} sampleRate=${sampleRate}`);
+			if (!isEnabled) return isEnabled;
+			return isEnabled;
+		} catch (e) {
+			logger_default.logError("[spiffy-ai] Error initializing amplitude session-replay", e);
+			return false;
+		}
+	}
+	createUnderlyingClient() {
+		const { amplitudeApiKey, dataResidency } = useEnviveConfig();
+		const currentAmplitudeInstance = createInstance();
+		const isSessionsEnabled = this.amplitudeSessionReplayInit();
+		currentAmplitudeInstance.add(this.getEventTrackingEnrichment());
+		currentAmplitudeInstance.init(amplitudeApiKey, this.userId, {
+			serverZone: dataResidency,
+			trackingOptions: { ipAddress: true },
+			autocapture: {
+				attribution: true,
+				pageViews: { trackHistoryChanges: "pathOnly" },
+				sessions: isSessionsEnabled,
+				formInteractions: false,
+				fileDownloads: false
+			}
+		});
+		return currentAmplitudeInstance;
+	}
+	getDefaultTrackingProps() {
+		const { env } = useEnviveConfig();
+		const gatesProps = this.orgConfig.gates ? this.orgConfig.gates.reduce((acc, curr) => {
+			if (curr.name && curr.value != null) return {
+				...acc,
+				[`feature_gate.${curr.name}`]: curr.value
+			};
+			return acc;
+		}, {}) : {};
+		const experimentProps = this.orgConfig.experiments ? this.orgConfig.experiments.reduce((acc, curr) => {
+			if (curr.name && curr.value != null) return {
+				...acc,
+				[`product_experiment.${curr.name}`]: curr.value
+			};
+			return acc;
+		}, {}) : {};
+		return {
+			...gatesProps,
+			...experimentProps,
+			...this.supplementalDefaultProps,
+			org_id: this.orgConfig.org?.org.id,
+			app_id: "commerce-chat-react-component",
+			chat_id: LocalStorageService.getItem(LocalStorageKeys.ChatId),
+			env: env || "unknown",
+			app_source: EnvironmentService.getContextSource(),
+			"org.short_name": this.orgConfig.org?.org.shortName,
+			"user.id": this.userId,
+			"cdp.user_id": null,
+			"cdp.provider": null,
+			"event.source": "web-browser",
+			"event.type": "user-activity",
+			"event.id": null,
+			"event.channel": "web",
+			"event.timestamp": null
+		};
+	}
+	static {
+		this.trackEvent = async ({ eventName, eventProps, eventGroups, alsoSendToGoogleAnalytics = false }) => {
+			try {
+				const decoratedEventName = `[Spiffy] ${eventName}`;
+				const amplitudeInstance = AmplitudeAdapter.getSingletonInstanceOf();
+				const amplitudeClient = amplitudeInstance.getUnderlyingAmplitudeClient();
+				if (!amplitudeClient) {
+					logger_default.logWarn("amplitude instance undefined", void 0, { event_name: decoratedEventName });
+					return;
+				}
+				const eventData = JSON.stringify({
+					eventName,
+					eventProps,
+					created_at: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				const data = new TextEncoder().encode(eventData);
+				const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+				const currentInsertId = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+				logger_default.logDebug(`amplitude tracking ${decoratedEventName}`, null, {
+					event_name: decoratedEventName,
+					props: eventProps
+				});
+				amplitudeClient.track(decoratedEventName, {
+					...amplitudeInstance.getDefaultTrackingProps(),
+					...eventProps,
+					...eventProps ? AmplitudeAdapter.getSingletonInstanceOf().eventPropsToPrefixedEventProps(eventName, eventProps) : {}
+				}, {
+					...eventGroups,
+					insert_id: currentInsertId
+				});
+				if (alsoSendToGoogleAnalytics && amplitudeInstance.orgGaConfig) {
+					const dataLayer = WindowDataLayerService.getSingletonInstanceOf(amplitudeInstance.orgGaConfig);
+					logger_default.logDebug("[spiffy-ai] GA tracking", decoratedEventName);
+					dataLayer.sendToGoogleAnalyticsCircularEventsSafe(decoratedEventName, eventProps);
+				}
+			} catch (err) {
+				logger_default.logError("[spiffy-ai] Error tracking event", err, {
+					eventName,
+					eventProps
+				});
+			}
+		};
+	}
+	static amplitudeSafeString(input) {
+		if (!input) return null;
+		if (input.length > 1024) return input.slice(0, 1024);
+		return input;
+	}
+	static getSingletonInstanceOf() {
+		if (EnvironmentService.getContextSource() === ContextSourceEnum.Test) return new StubAmplitudeAdapter();
+		const identifyingPrefix = EnvironmentService.getIdentifyingPrefix();
+		if (!window[identifyingPrefix]) window[identifyingPrefix] = {};
+		if (!window[identifyingPrefix]._amplitudeAdapter) {
+			const atomStore = getAtomStore();
+			const userId = atomStore.get(userIdAtom);
+			const orgConfig = atomStore.get(orgConfigAtom);
+			const orgGaConfig = atomStore.get(orgAnalyticsGoogleAnalyticsConfigAtom);
+			const featureFlagService = atomStore.get(featureFlagServiceAtom);
+			window[identifyingPrefix]._amplitudeAdapter = new AmplitudeAdapter(userId, orgConfig, featureFlagService, orgGaConfig);
+			window[identifyingPrefix]._amplitudeAdapter?.init();
+		}
+		return window[identifyingPrefix]._amplitudeAdapter;
+	}
+};
+
+//#endregion
+//#region src/adapters/amplitude/stubAmplitudeAdapter.ts
+var StubAmplitudeAdapter = class extends AmplitudeAdapter {
+	constructor() {
+		super("test", {}, {});
+		this.init = () => {};
+		this.getUnderlyingAmplitudeClient = () => void 0;
+		this.getSupplementalDefaultProps = () => ({});
+		this.setSupplementalDefaultProps = () => {};
+		this.getEventTrackingEnrichment = () => ({
+			name: "stub-enrichment",
+			type: "enrichment",
+			setup: async () => void 0,
+			execute: async (event) => event
+		});
+		this.amplitudeSessionReplayInit = () => false;
+		this.createUnderlyingClient = () => ({});
+		this.getDefaultTrackingProps = () => ({});
+		this.trackEvent = () => Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/application/utils/analyticsUtils.ts
+const NORMALIZED_ADD_TO_CART_EVENT_NAMES = ["addtocart", "addedtocart"];
+const CHECK_DATA_LAYER_INTERVAL_MS = 500;
+const CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;
+/**
+* Checks if a Google Analytics event is an add_to_cart event.
+*
+* @param event The event name to check.
+*
+* @returns True if the event is an add_to_cart event, false otherwise.
+*/
+const isAddToCartEvent = (event) => {
+	const normalizedEvent = event.replace(/[-_]/g, "").toLowerCase();
+	return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) => normalizedEvent.includes(name));
+};
+/**
+* Tracks an add_to_cart event in Amplitude.
+*
+* @param event The event to track.
+*/
+const handleAddToCartEvent = (event) => {
+	let eventProps;
+	if (isLegacyUAEcommerceEvent(event)) eventProps = {
+		items: event.ecommerce.add.products.map((product) => ({
+			item_name: product.name,
+			item_category: product.category,
+			price: product.price,
+			quantity: product.quantity
+		})),
+		currency: event.ecommerce.add.currencyCode,
+		event_format_version: "legacy_universal_analytics"
+	};
+	else if (isGA4EcommerceEvent(event)) eventProps = {
+		items: event.ecommerce.items.map((item) => ({
+			item_name: item.item_name,
+			item_category: item.item_category,
+			price: item.price,
+			quantity: item.quantity
+		})),
+		currency: event.ecommerce.currency,
+		event_format_version: "google_analytics_4"
+	};
+	else eventProps = {
+		event_properties: { ...event },
+		event_format_version: "unknown"
+	};
+	AmplitudeAdapter.trackEvent({
+		eventName: SpiffyMetricsEventName.AddToCartClicked,
+		eventProps
+	});
+};
+/**
+* Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.
+* This function runs on an interval until the dataLayer is available.
+*/
+const initDataLayerWrapper = () => {
+	let attempts = 0;
+	const checkAndInitialize = () => {
+		if (!window.dataLayer || !window.dataLayer.push) {
+			attempts += 1;
+			if (attempts >= CHECK_DATA_LAYER_MAX_ATTEMPTS) {
+				logger_default.logDebug(`[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`);
+				return;
+			}
+			setTimeout(checkAndInitialize, CHECK_DATA_LAYER_INTERVAL_MS);
+			return;
+		}
+		logger_default.logDebug("[spiffy-ai] dataLayer is available, wrapping push function...");
+		const originalPush = window.dataLayer.push;
+		window.dataLayer.push = (args) => {
+			if (isBaseEcommerceEvent(args) && isAddToCartEvent(args.event)) handleAddToCartEvent(args);
+			originalPush.apply(window.dataLayer, [args]);
+		};
+	};
+	checkAndInitialize();
+};
+const initAmplitude = () => {
+	AmplitudeAdapter.getSingletonInstanceOf();
+};
+
+//#endregion
+//#region src/application/utils/coreContextToApiContext.ts
+const coreContextToApiContext = (context) => ({
+	chat_id: context.chatId,
+	org_id: context.orgId,
+	user_id: context.userId,
+	org_short_name: context.orgShortName,
+	source: context.source,
+	env: context.env
+});
+
+//#endregion
+//#region src/application/utils/coreUserEventToApiUserEvent.ts
+const coreUserEventToApiUserEvent = (data) => {
+	if (data.category === UserEventCategory.PdpVisit || data.category === UserEventCategory.AddToCart) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			product_id: data.attributes.productId,
+			parent_product_id: data.attributes.parentProductId,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === UserEventCategory.PlpVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			category: PLPAttributeCategory.Id,
+			attributes: { id: data.attributes.attributes.id }
+		}
+	};
+	if (data.category === UserEventCategory.QueryTyped) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { query: data.attributes.query }
+	};
+	if (data.category === UserEventCategory.Search) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			search_term: data.attributes.searchTerm,
+			selected_filters: data.attributes.selectedFilters
+		}
+	};
+	if (data.category === UserEventCategory.SuggestionClicked) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { suggestion_id: data.attributes.suggestionId }
+	};
+	if (data.category === UserEventCategory.PageVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			url: data.attributes.url,
+			page_visit_category: data.attributes.pageVisitCategory
+		}
+	};
+	if (data.category === UserEventCategory.FormSubmitted) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			filled_schema: { ...data.attributes.filledSchema },
+			form_response_id: data.attributes.formResponseId,
+			form_type: data.attributes.formType
+		}
+	};
+	return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category
+	};
+};
+
+//#endregion
+//#region src/application/utils/divideArray.ts
+const divideArray = (array, size) => {
+	const rows = [];
+	for (let i = 0; i < size; i += 1) rows.push(array.filter((_, index) => index % size === i));
+	return rows;
+};
+
+//#endregion
+//#region src/application/utils/mutationHelper.ts
+const compareTokens = (original, comparison) => {
+	const originalTokens = new Set(original.split(" "));
+	const comparisonTokens = new Set(comparison.split(" "));
+	return [...originalTokens].filter((token) => !comparisonTokens.has(token));
+};
+var MutationHelper = class {
+	static fireClassChange(record, node, fn) {
+		if (node && record.oldValue !== node?.classList.value) fn(node?.classList);
+	}
+	static fireClassAdded(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(node?.classList.value, record.oldValue).forEach((className) => classMap.get(className)?.());
+	}
+	static fireClassRemoved(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(record.oldValue, node?.classList.value).forEach((className) => classMap.get(className)?.());
+	}
+	static fireSubtreeChange(nodes, fn) {
+		nodes.length && fn?.(nodes);
+	}
+	static isClass(mutation) {
+		return mutation.type === "attributes" && mutation.attributeName === "class";
+	}
+	static isChildList(mutation) {
+		return mutation.type === "childList";
+	}
+};
+
+//#endregion
+//#region src/application/utils/elementObserver.ts
+/**
+* The `ElementObserver` class monitors all changes related to the specific element it is responsible for.
+* It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.
+*
+* How it works:
+*
+* Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,
+* such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node
+* changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`
+* is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`
+* instance.
+*
+* Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.
+* When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.
+*
+*/
+var ElementObserver = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.mutation = null;
+		this.node = null;
+		this.eventListeners = /* @__PURE__ */ new Map();
+		this.classAdded = /* @__PURE__ */ new Map();
+		this.classRemoved = /* @__PURE__ */ new Map();
+		this.nodeDisplay = "block";
+		this.addFn = () => {};
+		this.removeFn = () => {};
+		this.changeFn = () => {};
+		this.classChangeFn = () => {};
+		this.addChildFn = void 0;
+		this.removeChildFn = void 0;
+		this.resetFn = () => {};
+	}
+	handleAttributes(mutationRecord) {
+		mutationRecord.filter(MutationHelper.isClass).forEach((mutation) => {
+			MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);
+			MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);
+			MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);
+		});
+	}
+	handleChildList(mutationRecord) {
+		if (!this.addChildFn && !this.removeChildFn) return;
+		mutationRecord.filter(MutationHelper.isChildList).forEach((mutation) => {
+			MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);
+			MutationHelper.fireSubtreeChange(mutation.removedNodes, this.removeChildFn);
+		});
+	}
+	addInitialListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.addEventListener(k, v));
+	}
+	clearEventListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.removeEventListener(k, v));
+		this.eventListeners.clear();
+	}
+	renew(newNode) {
+		if (newNode) {
+			this.destroy();
+			this.watch(newNode);
+		}
+	}
+	getSelector() {
+		return this.selector;
+	}
+	getNode() {
+		return this.node;
+	}
+	synchronize() {
+		const parsedNode = this.getSelector().parse();
+		if (this.getNode() !== parsedNode) {
+			this.renew(parsedNode);
+			return;
+		}
+		if (!this.getNode() && parsedNode) {
+			this.watch(parsedNode);
+			return;
+		}
+		if (this.getNode() && !parsedNode) this.destroy();
+	}
+	init() {
+		const node = this.getSelector().parse();
+		if (node) this.watch(node);
+	}
+	watch(node) {
+		if (!this.mutation) {
+			this.mutation = new MutationObserver((mutationRecord) => {
+				this.handleAttributes(mutationRecord);
+				this.handleChildList(mutationRecord);
+				this.changeFn(this.node);
+			});
+			this.mutation.observe(node, {
+				childList: true,
+				subtree: true,
+				attributes: true,
+				attributeOldValue: true
+			});
+			this.node = node;
+			this.addFn(this.node);
+			this.addInitialListeners();
+		}
+	}
+	destroy() {
+		this.resetFn();
+		this.removeFn(this.node);
+		this.mutation?.disconnect();
+		this.clearEventListeners();
+		this.classAdded.clear();
+		this.classRemoved.clear();
+		this.mutation = null;
+		this.node = null;
+	}
+	render(fn) {
+		if (this.node) return createPortal(fn(), this.node);
+	}
+	fire(event) {
+		if (this.node) this.node.dispatchEvent(new MouseEvent(event, {
+			bubbles: true,
+			cancelable: true,
+			view: window
+		}));
+	}
+	show() {
+		const display = this.node?.style.display;
+		if (this.node && display === "none") this.node.style.display = this.nodeDisplay || "block";
+	}
+	hide() {
+		const display = this.node?.style.display;
+		if (this.node && display !== "none") {
+			this.nodeDisplay = display || "block";
+			this.node.style.display = "none";
+		}
+	}
+	registerEvent(event, fn) {
+		if (this.node) {
+			const previousFn = this.eventListeners.get(event);
+			if (previousFn) this.node.removeEventListener(event, previousFn);
+			this.node.addEventListener(event, fn);
+		}
+		this.eventListeners.set(event, fn);
+	}
+	registerOnReset(fn) {
+		this.resetFn = fn;
+	}
+	registerOnChange(fn) {
+		this.changeFn = fn;
+	}
+	registerOnAdd(fn) {
+		this.addFn = fn;
+	}
+	registerOnRemove(fn) {
+		this.removeFn = fn;
+	}
+	registerOnclassChange(fn) {
+		this.classChangeFn = fn;
+	}
+	registerOnAddChild(fn) {
+		this.addChildFn = fn;
+	}
+	registerOnRemoveChild(fn) {
+		this.removeChildFn = fn;
+	}
+	registerOnClassAdded(className, fn) {
+		this.classAdded.set(className, fn);
+	}
+	registerOnClassRemoved(className, fn) {
+		this.classRemoved.set(className, fn);
+	}
+};
+
+//#endregion
+//#region src/application/utils/domObserver.ts
+/**
+* This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+* added or removed from the DOM and notifies the observers for each observable element
+* when they are ready to be watched.
+*
+* How that works:
+*
+* When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+* All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+* iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+*
+* If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+*
+* The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+* individual element observers and release any associated resources.
+*
+* There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+*
+*/
+var DOMObserver = class {
+	static {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	static notifyAdition(records, nodeMapping) {
+		records.forEach((record) => record.addedNodes.forEach((node) => {
+			nodeMapping.get(node)?.watch(node);
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyRemoval(records, nodeMapping) {
+		records.forEach((record) => record.removedNodes.forEach((node) => {
+			nodeMapping.get(node)?.destroy();
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyChildrenChanges(nodeMapping) {
+		Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());
+	}
+	static mapNodeInstancesToListeners() {
+		const nodeMapping = /* @__PURE__ */ new Map();
+		this.listeners.forEach((observer) => {
+			const node = observer.getNode() || observer.getSelector()?.parse();
+			if (node) nodeMapping.set(node, observer);
+		});
+		return nodeMapping;
+	}
+	static add(selector) {
+		const node = selector.getPattern();
+		let elementObserver = this.listeners.get(node);
+		if (elementObserver) return elementObserver;
+		elementObserver = new ElementObserver(selector);
+		this.listeners.set(node, elementObserver);
+		return elementObserver;
+	}
+	static remove(selector) {
+		const node = selector.getPattern();
+		this.listeners.get(node)?.destroy();
+		this.listeners.delete(node);
+	}
+	static observe() {
+		if (!this.documentObserver) {
+			this.documentObserver = new MutationObserver((mutations) => {
+				const nodeMapping = this.mapNodeInstancesToListeners();
+				this.notifyAdition(mutations, nodeMapping);
+				this.notifyRemoval(mutations, nodeMapping);
+				this.notifyChildrenChanges(nodeMapping);
+			});
+			this.documentObserver.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		}
+	}
+	static destroy() {
+		this.documentObserver?.disconnect();
+		this.listeners.forEach((listener) => listener.destroy());
+		this.listeners.clear();
+		this.documentObserver = null;
+	}
+};
+
+//#endregion
+//#region src/application/utils/imageFilter.ts
+const getRecentProductImageUrls = (lastMessages, currentProductId) => {
+	const productMessages = lastMessages.filter((message) => message.type === MessageType.Product && message.metadata?.imageUrl).map((m) => m);
+	return [...productMessages.filter((m) => m.metadata?.id === currentProductId), ...productMessages.filter((m) => m.metadata?.id !== currentProductId)].map((m) => m.metadata.imageUrl);
+};
+
+//#endregion
+//#region src/application/utils/merchantUtils.ts
+const prepareMerchantPage = () => {
+	let metaViewport = document.querySelector("meta[name='viewport']");
+	if (metaViewport) {
+		const content = metaViewport.getAttribute("content");
+		if (!content?.includes("maximum-scale=1")) metaViewport.setAttribute("content", `${content}, maximum-scale=1`);
+		return;
+	}
+	metaViewport = document.createElement("meta");
+	metaViewport.setAttribute("name", "viewport");
+	metaViewport.setAttribute("content", "width=device-width, initial-scale=1, maximum-scale=1");
+	document.head.appendChild(metaViewport);
+};
+
+//#endregion
+//#region src/application/utils/messageFromFormSubmittedEvent.ts
+const messageFromFormSubmittedEvent = (event, formResponseAttributes) => {
+	if (event.category !== UserEventCategory.FormSubmitted) return;
+	const formStringContents = Object.entries(formResponseAttributes.schema.properties).map(([key, value]) => `${value.title}: ${event.attributes.filledSchema[key]}`).join("\n");
+	return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.QueryTyped,
+		createdAt: event.createdAt,
+		metadata: { content: formStringContents }
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromQueryEvent.ts
+/**
+* Transforms a query UserEvent object into a Message object for presentation.
+*
+* @param event The user event object received from the server
+*
+* @returns A Message if the event is a query event, otherwise undefined
+*/
+const messageFromQueryEvent = (event) => {
+	if (event.category === UserEventCategory.QueryTyped) return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.QueryTyped,
+		createdAt: event.createdAt,
+		metadata: { content: event.attributes.query }
+	};
+	if (event.category === UserEventCategory.Search) return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.Search,
+		createdAt: event.createdAt,
+		metadata: {
+			searchTerm: event.attributes.searchTerm || "",
+			selectedFilters: event.attributes.selectedFilters || []
+		}
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromResponse.ts
+/**
+* Transforms a server Response object into a Message object for presentation.
+*
+* @param response The response object received from the server containing model generated content
+*
+* @returns A Message if the response contains known attributes, undefined otherwise
+*/
+const messageFromResponse = (response) => {
+	if (response == null) return;
+	if (response.category === ResponseCategory.Text) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Text,
+		role: MessageRole.Assistant,
+		metadata: { content: response.attributes.content }
+	};
+	if (response.category === ResponseCategory.Product) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Product,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.Review) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Review,
+		role: MessageRole.Assistant,
+		metadata: {
+			review: response.attributes.review,
+			reviewer: response.attributes.reviewer,
+			stars: response.attributes.stars,
+			title: response.attributes.title,
+			richInformation: response.attributes.richInformation
+		}
+	};
+	if (response.category === ResponseCategory.Separator) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Separator,
+		role: MessageRole.Assistant
+	};
+	if (response.category === ResponseCategory.Page) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Page,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.ProductSearch) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.ProductSearch,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.ProductSearchFilter) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.ProductSearchFilter,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.Form) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Form,
+		metadata: {
+			formType: response.attributes.formCategory?.formType,
+			fields: Object.entries(response.attributes.schema.properties).map(([key, value]) => ({
+				key,
+				title: value.title,
+				type: value.type,
+				format: value.format,
+				required: response.attributes.schema.required.includes(key)
+			}))
+		}
+	};
+	if (response.category === ResponseCategory.Order) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Order,
+		metadata: { ...response.attributes }
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromSuggestionEvent.ts
+/**
+* Transforms a UserEvent object into a Message object for presentation.
+*
+* @param event The UserEvent object received from the server
+* @param suggestions A list of generated suggestions to match the event to
+*
+* @returns A Message if the event is a suggestion click event, undefined otherwise
+*/
+const messageFromSuggestionEvent = (event, suggestions) => {
+	if (event.category === UserEventCategory.SuggestionClicked) {
+		const { suggestionId } = event.attributes;
+		return {
+			id: event.eventId,
+			role: MessageRole.User,
+			type: MessageType.SuggestionClicked,
+			createdAt: event.createdAt,
+			metadata: {
+				suggestionId,
+				suggestionContent: suggestions.find((s) => s.id === suggestionId)?.content ?? ""
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/application/utils/nextMessageRequestToApiRequest.ts
+const messageRequestToCommerceMessageRequest = (data) => ({
+	context: {
+		chat_id: data.context.chatId,
+		org_id: data.context.orgId,
+		org_short_name: data.context.orgShortName,
+		user_id: data.context.userId,
+		source: data.context.source,
+		env: data.context.env
+	},
+	id: data.id,
+	feature_flags: data.featureFlags,
+	user_events: data.userEvents?.map((userEvent) => coreUserEventToApiUserEvent(userEvent)),
+	generation_params: {
+		model: data.generationParams?.model,
+		max_tokens: data.generationParams?.maxTokens,
+		stop: data.generationParams?.stop,
+		stream: data.generationParams?.stream,
+		temperature: data.generationParams?.temperature,
+		top_p: data.generationParams?.topP,
+		num_suggestions: data.generationParams?.numSuggestions,
+		response_system_prompt: data.generationParams?.responseSystemPrompt,
+		suggestion_system_prompt: data.generationParams?.suggestionSystemPrompt,
+		response_caching: data.generationParams?.responseCaching
+	}
+});
+
+//#endregion
+//#region src/application/utils/nodeSelector.ts
+var NodeSelector = class {
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.root = document;
+	}
+	getPattern() {
+		return this.pattern;
+	}
+	setRoot(root) {
+		this.root = root;
+	}
+	getRoot() {
+		return this.root;
+	}
+};
+var QuerySelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().querySelector(this.getPattern());
+	}
+};
+var IDSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().getElementById(this.getPattern());
+	}
+};
+var XpathSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot()?.evaluate(this.getPattern(), this.getRoot(), null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)?.singleNodeValue;
+	}
+};
+var ChainSelector = class extends NodeSelector {
+	parse() {
+		let selectorIndex = 0;
+		const selectors = this.getPattern().split("@");
+		const lastIndex = selectors.length - 1;
+		const parseChain = (pattern, prevNode) => {
+			const selector = SelectorFactory.parse(pattern);
+			if (prevNode) selector.setRoot(prevNode);
+			const currentNode = selector.parse();
+			if (selectorIndex === lastIndex) return currentNode;
+			let node = currentNode || document;
+			if (currentNode?.shadowRoot) node = currentNode.shadowRoot;
+			if (currentNode?.contentWindow) node = currentNode.contentWindow?.document;
+			return parseChain(selectors[++selectorIndex].trim(), node);
+		};
+		return parseChain(selectors[selectorIndex].trim());
+	}
+};
+var Empty = class extends NodeSelector {
+	constructor() {
+		super("");
+	}
+	parse() {
+		return null;
+	}
+};
+var SelectorFactory = class {
+	static parse(composedSelector) {
+		if (!composedSelector) return new Empty();
+		const split = composedSelector.split("|");
+		const type = split[0];
+		const selector = split[1];
+		switch (type) {
+			case "id": return this.id(selector);
+			case "query": return this.query(selector);
+			case "xpath": return this.xpath(selector);
+			default: return new Empty();
+		}
+	}
+	static check(selector) {
+		return selector ?? new Empty();
+	}
+	static chain(pattern) {
+		return pattern ? new ChainSelector(pattern) : new Empty();
+	}
+	static id(pattern) {
+		return pattern ? new IDSelector(pattern) : new Empty();
+	}
+	static query(pattern) {
+		return pattern ? new QuerySelector(pattern) : new Empty();
+	}
+	static xpath(pattern) {
+		return pattern ? new XpathSelector(pattern) : new Empty();
+	}
+};
+
+//#endregion
+//#region src/application/utils/overrides.ts
+function isPlainObject(x) {
+	return !!x && typeof x === "object" && !Array.isArray(x) && !(x instanceof Date) && !(x instanceof RegExp);
+}
+function isReplace(x) {
+	return !!x && typeof x === "object" && "$replace" in x;
+}
+function isDelete(x) {
+	return !!x && typeof x === "object" && x.$delete === true;
+}
+function isPrimitiveValue(x) {
+	const t = typeof x;
+	return x === null || t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol" || t === "undefined";
+}
+function isArrayOfPrimitives(arr) {
+	if (arr.length === 0) return false;
+	for (let i = 0; i < arr.length; i += 1) {
+		const v = arr[i];
+		if (v !== void 0 && !isPrimitiveValue(v)) return false;
+	}
+	return true;
+}
+function mergeAny(baseAny, patchAny, opts) {
+	if (isReplace(patchAny)) return patchAny.$replace;
+	if (isDelete(patchAny)) return void 0;
+	if (Array.isArray(baseAny)) {
+		if (Array.isArray(patchAny)) {
+			const baseArr = baseAny;
+			const patchArr = patchAny;
+			if (opts.arrayStrategy === "replace" || isArrayOfPrimitives(baseArr) || isArrayOfPrimitives(patchArr)) return patchAny;
+			const out = baseArr.slice();
+			const max = Math.max(out.length, patchArr.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patchArr[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return baseAny;
+	}
+	if (isPlainObject(baseAny) && isPlainObject(patchAny)) {
+		const baseObj = baseAny;
+		const patchObj = patchAny;
+		const out = { ...baseObj };
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (opts.nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else out[key] = mergeAny(baseObj?.[key], pVal, opts);
+		}
+		return out;
+	}
+	return patchAny ?? baseAny;
+}
+function applyOverrides(base, patch, opts = {}) {
+	const { arrayStrategy = "mergeByIndex", nullDeletes = false } = opts;
+	if (isReplace(patch)) return patch.$replace;
+	if (isDelete(patch)) return void 0;
+	if (Array.isArray(base)) {
+		if (isReplace(patch)) return patch.$replace;
+		if (Array.isArray(patch)) {
+			if (arrayStrategy === "replace") return patch;
+			const out = base.slice();
+			const max = Math.max(out.length, patch.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patch[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return base;
+	}
+	if (isPlainObject(base) && isPlainObject(patch)) {
+		const out = { ...base };
+		const patchObj = patch;
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else {
+				const bVal = base[key];
+				out[key] = mergeAny(bVal, pVal, opts);
+			}
+		}
+		return out;
+	}
+	return patch ?? base;
+}
+
+//#endregion
+//#region src/application/utils/stringUtils.ts
+var StringUtils = class StringUtils {
+	static isNullOrEmpty(value) {
+		const valueTrimmed = value?.trim();
+		return value === void 0 || valueTrimmed === "";
+	}
+	static trimToNull(value) {
+		const valueTrimmed = value?.trim();
+		return StringUtils.isNullOrEmpty(valueTrimmed) ? void 0 : valueTrimmed;
+	}
+	static capitalize(type) {
+		if (type === void 0) return "";
+		return type.charAt(0).toUpperCase() + type.substring(1);
+	}
+	/**
+	* Finds the first pattern in an array that matches a given URL.
+	* Patterns can include a single wildcard '*' which matches any sequence of characters.
+	*
+	* @param patterns
+	* @param urlToTest
+	* @returns
+	*/
+	static findMatchingPattern(patterns, urlToTest) {
+		if (!urlToTest) return;
+		for (const pattern of patterns) if (urlToTest.pathname !== "/") {
+			const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+			if ((/* @__PURE__ */ new RegExp(`^${regexPattern}$`)).test(urlToTest.pathname)) return pattern;
+		} else if (pattern.startsWith(urlToTest.hostname)) return pattern;
+	}
+};
+
+//#endregion
+//#region src/application/utils/supportedEventRequestToApiRequest.ts
+const coreSupportedEventRequestToApiRequest = (coreSupportedEventRequest) => ({
+	id: coreSupportedEventRequest.id,
+	user_event: coreUserEventToApiUserEvent(coreSupportedEventRequest.userEvent),
+	context: coreContextToApiContext(coreSupportedEventRequest.context)
+});
+
+//#endregion
+//#region src/application/utils/validation.ts
+const validateEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+
+//#endregion
+//#region src/adapters/spiffy/commerce/exceptions/sessionExceptions.ts
+var SessionRestartRequired = class extends Error {
+	constructor() {
+		super("Session restart required");
+		this.name = "SessionRestartRequired";
+	}
+};
+
+//#endregion
+//#region src/adapters/spiffy/commerce/exceptions/unsupportedProductExceptions.ts
+var UnsupportedProductException = class extends Error {
+	constructor() {
+		super("Unsupported product");
+		this.name = "UnsupportedProduct";
+	}
+};
+
+//#endregion
+//#region src/adapters/spiffy/commerce/api.ts
+async function errorResponseBody(error) {
+	try {
+		return await error.response.json();
+	} catch {
+		return {};
+	}
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+	if (!(error instanceof ResponseError)) {
+		logger_default.logInfo(errorMsg, error);
+		throw error;
+	}
+	const errorResponse = await errorResponseBody(error);
+	if (errorResponse?.message?.toLowerCase() === "unsupported product" || errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND") throw new UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		logger_default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new SessionRestartRequired();
+	}
+	logger_default.logInfo(errorMsg, error);
+	throw error;
+}
+var CommerceApiClient = class CommerceApiClient {
+	static {
+		this.getInstance = () => {
+			if (!CommerceApiClient.instance) {
+				const apiKey = getAtomStore().get(apiKeyAtom);
+				CommerceApiClient.instance = new CommerceApiClient(apiKey);
+			}
+			return CommerceApiClient.instance;
+		};
+	}
+	constructor(apiKey, basePath) {
+		this.suggestionsAbortController = new AbortController();
+		this.responsesAbortController = new AbortController();
+		const { baseUrl } = useEnviveConfig();
+		const config = new Configuration({
+			accessToken: apiKey,
+			basePath: basePath || baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		this.defaultApi = new DefaultApi(config);
+		this.inferenceApi = new InferenceApi(config);
+		this.customerServiceApi = new CustomerServiceApi(config);
+	}
+	static {
+		this.resolveUrl = async (url) => {
+			const atomStore = getAtomStore();
+			const appDetails = atomStore.get(appDetailsAtom);
+			const featureFlagService = atomStore.get(featureFlagServiceAtom);
+			const context = {
+				user_id: appDetails.userId,
+				org_id: appDetails.orgId,
+				org_short_name: appDetails.orgShortName,
+				chat_id: appDetails.chatId,
+				source: appDetails.source,
+				env: appDetails.env
+			};
+			const featureGates = featureFlagService.getFeatureFlags();
+			const urlResolvingRequest = {
+				url,
+				context,
+				feature_gates: featureGates
+			};
+			return await (await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({ UrlResolvingRequest: urlResolvingRequest })).raw.json();
+		};
+	}
+	static {
+		this.reportSession = async (reportRequest) => {
+			await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({ ReportSessionRequest: reportRequest });
+		};
+	}
+	static {
+		this.getNextResponses = async (payload) => {
+			try {
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) })).map((resp) => validateResponse(resp)).map((resp) => messageFromResponse(resp)).filter((m) => m != null);
+			} catch (err) {
+				logger_default.logInfo("Failed to get next responses", err, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("Failed to get next responses", err);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getNextResponseStreaming = (payload) => {
+			async function* generate(inferenceApi, abortController) {
+				try {
+					const response = await inferenceApi.v1NextResponsesPostRaw({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) }, { signal: abortController.signal });
+					if (!response.raw.body) {
+						logger_default.logError("[spiffy-ai] No body in the streamed response", void 0, { response: response.raw });
+						return;
+					}
+					const reader = response.raw.body.getReader();
+					const decoder = new TextDecoder("utf-8");
+					let partial = "";
+					const safeParse = (line) => {
+						try {
+							return JSON.parse(line);
+						} catch (err) {
+							logger_default.logError("[spiffy-ai] Error parsing streamed line", err, {
+								line,
+								partial
+							});
+							partial = line;
+							return partial;
+						}
+					};
+					const processChunk = (chunk) => {
+						return `${partial}${chunk}`.split("\n").map((line) => line.replace(/^data: /, "").trim()).filter((line) => line !== "" && line !== "[DONE]").map(safeParse).filter((v) => v);
+					};
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						const chunk = decoder.decode(value);
+						const parsedLines = processChunk(chunk);
+						for (const parsedLine of parsedLines) {
+							const validatedResponse = validateResponse(parsedLine);
+							if (validatedResponse) yield validatedResponse;
+						}
+					}
+				} catch (error) {
+					logger_default.logError("[spiffy-ai] Failed to get next streaming responses", error, {
+						payloadContext: payload?.context,
+						userEvents: payload?.userEvents
+					});
+					await throwSessionRestartRequiredIf("Failed to get next streaming responses", error);
+				}
+			}
+			CommerceApiClient.getInstance().responsesAbortController.abort();
+			CommerceApiClient.getInstance().responsesAbortController = new AbortController();
+			return generate(CommerceApiClient.getInstance().inferenceApi, CommerceApiClient.getInstance().responsesAbortController);
+		};
+	}
+	static {
+		this.getNextSuggestions = async (payload) => {
+			try {
+				CommerceApiClient.getInstance().suggestionsAbortController.abort();
+				CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) }, { signal: CommerceApiClient.getInstance().suggestionsAbortController.signal })).map((resp) => validateSuggestion(resp)).filter((suggestion) => suggestion != null);
+			} catch (error) {
+				logger_default.logInfo("Failed to get suggestions", error, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("Failed to get suggestions", error);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getResponses = async (orgId, chatId, userId) => {
+			let data = {
+				responses: [],
+				suggestions: [],
+				user_events: []
+			};
+			const request = {
+				org_id: orgId,
+				chat_id: chatId,
+				user_id: userId
+			};
+			try {
+				data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);
+			} catch (error) {
+				await throwSessionRestartRequiredIf("Failed to get chat responses", error);
+			}
+			const responses = data?.responses?.map((turn) => turn.map((response) => validateResponse(response)).filter((response) => response != null));
+			const suggestions = data?.suggestions.map((suggestion) => validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+			const userEvents = data?.user_events.map((event) => validateUserEvent(event)).filter((event) => event != null);
+			const formSubmittedUserEventsFormIds = userEvents.filter((event) => event.category === UserEventCategory.FormSubmitted).map((event) => event.attributes.formResponseId);
+			const assistantMessages = responses.map((turn) => turn.filter((response) => !(response.category === ResponseCategory.Form && formSubmittedUserEventsFormIds.includes(response.id))).map((response) => messageFromResponse(response)).filter((message) => message != null)).filter((turn) => turn.length > 0);
+			const userMessages = userEvents.map((event) => {
+				if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) return [messageFromQueryEvent(event)];
+				if (event.category === UserEventCategory.SuggestionClicked) return [messageFromSuggestionEvent(event, suggestions)];
+				if (event.category === UserEventCategory.FormSubmitted) {
+					const formResponse = responses.flat().find((response) => response.id === event.attributes.formResponseId && event.attributes.formType !== FormType.Escalation);
+					if (formResponse && formResponse.category === ResponseCategory.Form) return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
+				}
+				return [];
+			}).filter((message) => message.length > 0);
+			const sortedMessages = [...assistantMessages, ...userMessages].sort((a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime());
+			return {
+				responses,
+				userEvents,
+				suggestions,
+				messages: sortedMessages
+			};
+		};
+	}
+	static {
+		this.isSupportedEvent = async (payload) => {
+			try {
+				const httpResponseText = await (await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({ SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload) })).raw.text();
+				const httpResponseJson = JSON.parse(httpResponseText);
+				return {
+					...httpResponseJson,
+					numberOfReviews: httpResponseJson.num_of_reviews,
+					merchant_tags: httpResponseJson.merchant_tags || []
+				};
+			} catch (err) {
+				logger_default.logError("Failed to get response for v1SupportedEventPost", { err });
+				return {
+					supported: false,
+					ready: false,
+					category: void 0,
+					collections: [],
+					numberOfReviews: void 0,
+					top_category: void 0,
+					merchant_tags: []
+				};
+			}
+		};
+	}
+	static {
+		this.identifyUser = async (spiffyUserId, merchantUserId, uaDetails) => {
+			try {
+				await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({ AnalyticsIdentifyRequest: {
+					user_id: spiffyUserId,
+					os_name: uaDetails.os,
+					os_version: uaDetails.osVersion,
+					platform: uaDetails.os,
+					device_id: uaDetails.deviceModel,
+					device_brand: uaDetails.deviceBrand,
+					device_manufacturer: uaDetails.deviceManufacturer,
+					device_model: uaDetails.deviceModel,
+					user_properties: {
+						cdp_user_id: merchantUserId,
+						browser: uaDetails.browser,
+						browser_version: uaDetails.browserVersion,
+						user_agent: uaDetails.userAgent
+					}
+				} });
+			} catch (err) {
+				logger_default.logError("Failed to identify user", err);
+			}
+		};
+	}
+	static {
+		this.mapContextSourceToV1OrgConfigGetSource = (source) => {
+			if (source === void 0) return void 0;
+			switch (source) {
+				case ContextSourceEnum.Fork: return V1OrgConfigGetSourceEnum.Fork;
+				case ContextSourceEnum.Playground: return V1OrgConfigGetSourceEnum.Playground;
+				case ContextSourceEnum.App: return V1OrgConfigGetSourceEnum.App;
+				case ContextSourceEnum.Test: return V1OrgConfigGetSourceEnum.Test;
+				default: return source;
+			}
+		};
+	}
+	static {
+		this.getOrgConfig = async (user_id) => {
+			try {
+				const { reactAppName } = useEnviveConfig();
+				const request = {
+					namespace: reactAppName,
+					user_id,
+					source: this.mapContextSourceToV1OrgConfigGetSource(EnvironmentService.getContextSource()),
+					include_experiments: Object.values(ProductExperiment),
+					include_feature_gates: Object.values(FeatureGates)
+				};
+				const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);
+				return validateOrgConfigResults(response);
+			} catch (err) {
+				logger_default.logError(`Failed to get org config`, err, { err });
+				return;
+			}
+		};
+	}
+	static {
+		this.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+			logger_default.logInfo(`addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`);
+			try {
+				await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost({ AddNoteToLatestConversationRequest: {
+					spiffy_user_id: spiffyUserId,
+					email,
+					customer_service_provider: customerServiceProvider
+				} });
+			} catch (err) {
+				logger_default.logError("Failed to add note to latest conversation", { err });
+			}
+		};
+	}
+	static {
+		this.getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;
+	}
+};
+var api_default = CommerceApiClient;
+
+//#endregion
+export { APP_INITIAL_START_TIME_KEY, AmplitudeAdapter, ChatElementDisplayLocation, DOMInsertionService, DOMInsertionType, DOMInsertionTypeToInsertPosition, DOMObserver, DomMutationObserverContinuation, DomObservationStrategy, ElementObserver, EnvironmentService, FeatureFlagService, FeatureGates, GoogleAnalyticsEvents, GridInsertionService, GridInsertionType, LocalStorageKeys, LocalStorageService, MessageRole, MessageType, MutationHelper, NodeSelector, PAGE_LOAD_OFFSET_TIME_KEY, PerfMetricsEvents, ProductExperiment, SelectorFactory, SessionRestartRequired, SessionStorageService, SpiffyEventName, SpiffyMetricsEventName, SpiffyWidgets, StringUtils, StubAmplitudeAdapter, UnsupportedProductException, UserIdentityService, WindowDataLayerService, addWidget, apiKeyAtom, api_default, appDetailsAtom, appInitialStartTimeMsAtom, appSourceAtom, applyOverrides, askQuestionBtnClickedAtom, buildSearchHash, buildSearchStartHash, chatAtom, chatIdAtom, chatIsOpenAtom, chatOnToggleAtom, clearUserEventAtom, colorsConfigAtom, coreContextToApiContext, coreSupportedEventRequestToApiRequest, coreUserEventToApiUserEvent, createResponsePayload, createUrlWithQueryParams, divideArray, endpointURLAtom, envAtom, featureFlagServiceAtom, formSubmitAtom, frontendConfigAtom, getApiKeyEnvVar, getAsyncOrgConfig, getMerchantColorsQuery, getMerchantFrontendConfigQuery, getMerchantOrgIdQuery, getOrgUIConfig, getQueryParam, getRecentProductImageUrls, handleFormSubmittedAtom, handleReplyAtom, handleSuggestionAtom, hasParsedVariantInfoAtom, hasReportedPerformanceMetricsAtom, initAmplitude, initDataLayerWrapper, isApiFormResponseAttributes, isApiFormSubmittedResponseAttributes, isApiOrderResponseAttributes, isApiOrgConfigResults, isApiOrganizationConfig, isApiPLPEventAttributes, isApiPLPIdAttribute, isApiPageResponseAttributes, isApiProductSearchFilterResponseAttributes, isBaseEcommerceEvent, isGA4EcommerceEvent, isGraphQLColorsConfig, isLegacyUAEcommerceEvent, isMobilePLPChatPlacementParameter, isSpanxTakeAQuizCtaParameter, isVariantInfo, lastAssistantMessageAtom, logPerfMetricAtom, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest, messagesAtom, orgAnalyticsAmplitudeConfigAtom, orgAnalyticsConfigAtom, orgAnalyticsCustomerServiceConfigAtom, orgAnalyticsGoogleAnalyticsConfigAtom, orgConfigAtom, orgCustomerServiceConfig, orgCustomerServiceService, orgDomainAtom, orgIdAtom, orgShortNameAtom, orgUIConfigAtom, pageLoadOffsetTimeAtom, parseHref, parseSearchHash, performanceMetricsAtom, prepareMerchantPage, processUserEventAtom, queueUserEventAtom, replyEventCategoryAtom, requestFailureAtom, resetPerformanceMetricsAtom, resetStoredOrgConfigAtom, responseStreamingAtom, sourceAtom, storedOrgConfigAtom, stringToFulfillmentDisplayStatusEnumValue, suggestionAtom, suggestionsAtom, suggestionsLoadingAtom, supportedEventAtom, transformCamelToSnake, transformSnakeToCamel, urlResolverAtom, userEventQueueAtom, userEventsAtom, userHasRepliedAtom, userIdAtom, userQueryAtom, userQueueEventCountAtom, validateAndTransformMountingConfig, validateAndTransformPageVariants, validateAndTransformWidgetConfig, validateEmail, validateGraphQLColorsConfig, validateGraphQLFrontendConfig, validateGraphQLOrgId, validateMobilePLPChatPlacementParameter, validateOrgConfigResults, validateOrganizationConfig, validateResponse, validateSuggestion, validateUserEvent, variantInfoAtom, widgetArrayAtom };