@nuskin/react-search-sdk 1.0.0-comx-2233.3 → 1.0.0-trying-again.1

package/dist/index.js

@@ -1,10 +1,8 @@
 'use strict';
 
-var React = require('react');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
+var react = require('react');
+var reactSearchComponents = require('@nuskin/react-search-components');
+var jsxRuntime = require('react/jsx-runtime');
 
 // src/constants.ts
 var STOREFRONT_SHOPPING_CONTEXT = "storefront";
@@ -18,9 +16,6 @@ var DEBOUNCE_MS = 220;
 var MAX_VISIBLE_SUGGESTIONS = 6;
 var SEARCH_PLACEHOLDER = "Search by product name, ingredient, benefits, or SKU";
 var TRIGGER_PLACEHOLDER = "Product Search";
-var DEFAULT_AI_CHAT_BASE_URL = "https://admin.tst.nuskin.ai/api/analytics/v1/embed";
-var DEFAULT_AI_CHAT_CONVERSATIONS_URL = `${DEFAULT_AI_CHAT_BASE_URL}/conversations`;
-var DEFAULT_AI_CHAT_MESSAGES_URL = `${DEFAULT_AI_CHAT_BASE_URL}/messages`;
 
 // src/services/SearchApiService.ts
 var DEFAULT_SEARCH_PLACEHOLDER = TRIGGER_PLACEHOLDER;
@@ -406,549 +401,6 @@ function createSearchService(options = {}) {
   return service;
 }
 
-// node_modules/eventsource-parser/dist/errors.js
-var ParseError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "ParseError";
-    this.type = options.type;
-    this.field = options.field;
-    this.value = options.value;
-    this.line = options.line;
-  }
-};
-
-// node_modules/eventsource-parser/dist/parse.js
-var LF = 10;
-var CR = 13;
-var SPACE = 32;
-var MAX_FIELD_PREFIX_LENGTH = 6;
-function noop(_arg) {
-}
-function createParser(config) {
-  if (typeof config === "function") {
-    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
-  }
-  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config;
-  const pendingFragments = [];
-  let pendingFragmentsLength = 0;
-  let isFirstChunk = true;
-  let id;
-  let data = "";
-  let dataLines = 0;
-  let eventType;
-  let terminated = false;
-  let skippingLine = false;
-  let skipNextLineFeed = false;
-  function feed(chunk) {
-    if (terminated) {
-      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
-    }
-    if (isFirstChunk) {
-      isFirstChunk = false;
-      if (chunk.charCodeAt(0) === 65279) {
-        chunk = chunk.slice(1);
-      } else if (chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191) {
-        chunk = chunk.slice(3);
-      }
-    }
-    if (skippingLine || skipNextLineFeed) {
-      chunk = resumeAfterSkip(chunk);
-      if (!chunk) {
-        return;
-      }
-    }
-    if (!pendingFragments.length) {
-      const trailing = processLines(chunk);
-      if (trailing !== "") {
-        storeTrailing(trailing);
-      }
-      checkBufferSize();
-      return;
-    }
-    if (chunk.indexOf("\n") === -1 && chunk.indexOf("\r") === -1) {
-      if (pendingFragmentsLength < MAX_FIELD_PREFIX_LENGTH) {
-        const head = pendingFragments.join("") + chunk.slice(0, MAX_FIELD_PREFIX_LENGTH - pendingFragmentsLength);
-        if (!shouldBufferTrailing(head)) {
-          pendingFragments.length = 0;
-          pendingFragmentsLength = 0;
-          skippingLine = true;
-          return;
-        }
-      }
-      pendingFragments.push(chunk);
-      pendingFragmentsLength += chunk.length;
-      checkBufferSize();
-      return;
-    }
-    pendingFragments.push(chunk);
-    const input = pendingFragments.join("");
-    pendingFragments.length = 0;
-    pendingFragmentsLength = 0;
-    storeTrailing(processLines(input));
-    checkBufferSize();
-  }
-  function resumeAfterSkip(chunk) {
-    if (chunk.length === 0) {
-      return chunk;
-    }
-    if (skipNextLineFeed) {
-      skipNextLineFeed = false;
-      return chunk.charCodeAt(0) === LF ? chunk.slice(1) : chunk;
-    }
-    const crIndex = chunk.indexOf("\r");
-    const lfIndex = chunk.indexOf("\n");
-    const lineEnd = crIndex === -1 ? lfIndex : lfIndex === -1 ? crIndex : crIndex < lfIndex ? crIndex : lfIndex;
-    if (lineEnd === -1) {
-      return "";
-    }
-    if (lineEnd === chunk.length - 1 && chunk.charCodeAt(lineEnd) === CR) {
-      skippingLine = false;
-      skipNextLineFeed = true;
-      return "";
-    }
-    skippingLine = false;
-    return chunk.slice(lineEnd + (chunk.charCodeAt(lineEnd) === CR && chunk.charCodeAt(lineEnd + 1) === LF ? 2 : 1));
-  }
-  function storeTrailing(trailing) {
-    if (!trailing)
-      return;
-    if (trailing.charCodeAt(trailing.length - 1) === CR) {
-      parseLine(trailing, 0, trailing.length - 1);
-      skipNextLineFeed = true;
-      return;
-    }
-    if (shouldBufferTrailing(trailing)) {
-      pendingFragments.push(trailing);
-      pendingFragmentsLength = trailing.length;
-      return;
-    }
-    skippingLine = true;
-  }
-  function shouldBufferTrailing(trailing) {
-    const firstCharCode = trailing.charCodeAt(0);
-    return firstCharCode === 58 && !!onComment || firstCharCode === 100 && isPotentialField(trailing, "data") || firstCharCode === 101 && isPotentialField(trailing, "event") || firstCharCode === 105 && isPotentialField(trailing, "id") || firstCharCode === 114 && isPotentialField(trailing, "retry");
-  }
-  function checkBufferSize() {
-    if (maxBufferSize === void 0)
-      return;
-    if (pendingFragmentsLength + data.length <= maxBufferSize)
-      return;
-    terminated = true;
-    pendingFragments.length = 0;
-    pendingFragmentsLength = 0;
-    id = void 0;
-    data = "";
-    dataLines = 0;
-    eventType = void 0;
-    skippingLine = false;
-    skipNextLineFeed = false;
-    onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
-      type: "max-buffer-size-exceeded"
-    }));
-  }
-  function processLines(chunk) {
-    let searchIndex = 0;
-    if (chunk.indexOf("\r") === -1) {
-      let lfIndex = chunk.indexOf("\n", searchIndex);
-      while (lfIndex !== -1) {
-        if (searchIndex === lfIndex) {
-          if (dataLines > 0) {
-            onEvent({ id, event: eventType, data });
-          }
-          id = void 0;
-          data = "";
-          dataLines = 0;
-          eventType = void 0;
-          searchIndex = lfIndex + 1;
-          lfIndex = chunk.indexOf("\n", searchIndex);
-          continue;
-        }
-        const firstCharCode = chunk.charCodeAt(searchIndex);
-        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
-          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5;
-          const value = chunk.slice(valueStart, lfIndex);
-          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
-            onEvent({ id, event: eventType, data: value });
-            id = void 0;
-            data = "";
-            eventType = void 0;
-            searchIndex = lfIndex + 2;
-            lfIndex = chunk.indexOf("\n", searchIndex);
-            continue;
-          }
-          data = dataLines === 0 ? value : `${data}
-${value}`;
-          dataLines++;
-        } else if (isEventPrefix(chunk, searchIndex, firstCharCode)) {
-          eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0;
-        } else {
-          parseLine(chunk, searchIndex, lfIndex);
-        }
-        searchIndex = lfIndex + 1;
-        lfIndex = chunk.indexOf("\n", searchIndex);
-      }
-      return chunk.slice(searchIndex);
-    }
-    while (searchIndex < chunk.length) {
-      const crIndex = chunk.indexOf("\r", searchIndex);
-      const lfIndex = chunk.indexOf("\n", searchIndex);
-      let lineEnd = -1;
-      if (crIndex !== -1 && lfIndex !== -1) {
-        lineEnd = crIndex < lfIndex ? crIndex : lfIndex;
-      } else if (crIndex !== -1) {
-        if (crIndex === chunk.length - 1) {
-          lineEnd = -1;
-        } else {
-          lineEnd = crIndex;
-        }
-      } else if (lfIndex !== -1) {
-        lineEnd = lfIndex;
-      }
-      if (lineEnd === -1) {
-        break;
-      }
-      parseLine(chunk, searchIndex, lineEnd);
-      searchIndex = lineEnd + 1;
-      if (chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF) {
-        searchIndex++;
-      }
-    }
-    return chunk.slice(searchIndex);
-  }
-  function parseLine(chunk, start, end) {
-    if (start === end) {
-      dispatchEvent();
-      return;
-    }
-    const firstCharCode = chunk.charCodeAt(start);
-    if (isDataPrefix(chunk, start, firstCharCode)) {
-      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5;
-      const value2 = chunk.slice(valueStart, end);
-      data = dataLines === 0 ? value2 : `${data}
-${value2}`;
-      dataLines++;
-      return;
-    }
-    if (isEventPrefix(chunk, start, firstCharCode)) {
-      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
-      return;
-    }
-    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
-      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
-      if (!value2.includes("\0"))
-        id = value2;
-      return;
-    }
-    if (firstCharCode === 58) {
-      if (onComment) {
-        const line2 = chunk.slice(start, end);
-        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
-      }
-      return;
-    }
-    const line = chunk.slice(start, end);
-    const fieldSeparatorIndex = line.indexOf(":");
-    if (fieldSeparatorIndex === -1) {
-      processField(line, "", line);
-      return;
-    }
-    const field = line.slice(0, fieldSeparatorIndex);
-    const offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
-    const value = line.slice(fieldSeparatorIndex + offset);
-    processField(field, value, line);
-  }
-  function processField(field, value, line) {
-    switch (field) {
-      case "event":
-        eventType = value || void 0;
-        break;
-      case "data":
-        data = dataLines === 0 ? value : `${data}
-${value}`;
-        dataLines++;
-        break;
-      case "id":
-        if (!value.includes("\0"))
-          id = value;
-        break;
-      case "retry":
-        if (/^\d+$/.test(value)) {
-          onRetry(parseInt(value, 10));
-        } else {
-          onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
-            type: "invalid-retry",
-            value,
-            line
-          }));
-        }
-        break;
-      default:
-        onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
-        break;
-    }
-  }
-  function dispatchEvent() {
-    if (dataLines > 0) {
-      onEvent({
-        id,
-        event: eventType,
-        data
-      });
-    }
-    id = void 0;
-    data = "";
-    dataLines = 0;
-    eventType = void 0;
-  }
-  function reset(options = {}) {
-    if (options.consume && pendingFragments.length > 0) {
-      const incompleteLine = pendingFragments.join("");
-      parseLine(incompleteLine, 0, incompleteLine.length);
-    }
-    isFirstChunk = true;
-    id = void 0;
-    data = "";
-    dataLines = 0;
-    eventType = void 0;
-    pendingFragments.length = 0;
-    pendingFragmentsLength = 0;
-    terminated = false;
-    skippingLine = false;
-    skipNextLineFeed = false;
-  }
-  return { feed, reset };
-}
-function isDataPrefix(chunk, i, firstCharCode) {
-  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
-}
-function isEventPrefix(chunk, i, firstCharCode) {
-  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
-}
-function isPotentialField(line, field) {
-  let i = 1;
-  while (i < line.length && i < field.length) {
-    if (line.charCodeAt(i) !== field.charCodeAt(i)) {
-      return false;
-    }
-    i++;
-  }
-  return line.length <= field.length || line.charCodeAt(field.length) === 58;
-}
-
-// src/services/ChatService.ts
-var PRODUCTS_OPENING_FENCE = "```products";
-var MARKDOWN_CLOSING_FENCE = "\n```";
-function findProductsBlockStart(content, openingFenceIndex) {
-  let blockStart = openingFenceIndex + PRODUCTS_OPENING_FENCE.length;
-  while (blockStart < content.length && (content[blockStart] === " " || content[blockStart] === "	" || content[blockStart] === "\r")) {
-    blockStart += 1;
-  }
-  return content[blockStart] === "\n" ? blockStart + 1 : null;
-}
-function isStandaloneClosingFence(content, fenceEnd) {
-  const lineEnd = content.indexOf("\n", fenceEnd);
-  const suffixEnd = lineEnd === -1 ? content.length : lineEnd;
-  return content.slice(fenceEnd, suffixEnd).trim() === "";
-}
-function findClosingFence(content, fromIndex) {
-  let candidate = content.indexOf(MARKDOWN_CLOSING_FENCE, fromIndex);
-  while (candidate !== -1) {
-    const fenceEnd = candidate + MARKDOWN_CLOSING_FENCE.length;
-    if (isStandaloneClosingFence(content, fenceEnd)) {
-      return candidate;
-    }
-    candidate = content.indexOf(MARKDOWN_CLOSING_FENCE, fenceEnd);
-  }
-  return -1;
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object";
-}
-function getRenderProductListItems(event) {
-  if (event["type"] !== "render" || event["pattern"] !== "product_list") {
-    return [];
-  }
-  const data = event["data"];
-  if (!isRecord(data) || !Array.isArray(data["items"])) {
-    return [];
-  }
-  return data["items"].filter(isRecord);
-}
-function extractProductsFromMarkdown(content) {
-  const products = [];
-  const summaryParts = [];
-  let summaryCursor = 0;
-  let searchCursor = 0;
-  while (searchCursor < content.length) {
-    const start = content.indexOf(PRODUCTS_OPENING_FENCE, searchCursor);
-    if (start === -1) break;
-    const blockStart = findProductsBlockStart(content, start);
-    if (blockStart === null) {
-      searchCursor = start + PRODUCTS_OPENING_FENCE.length;
-      continue;
-    }
-    const nextOpeningFence = content.indexOf(
-      PRODUCTS_OPENING_FENCE,
-      blockStart
-    );
-    const end = findClosingFence(content, blockStart);
-    if (end === -1) break;
-    if (nextOpeningFence !== -1 && nextOpeningFence < end) {
-      searchCursor = nextOpeningFence;
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(content.slice(blockStart, end));
-      if (Array.isArray(parsed)) {
-        products.push(...parsed);
-      }
-    } catch (e) {
-      console.error("Failed to parse products block:", e);
-    }
-    summaryParts.push(content.slice(summaryCursor, start));
-    summaryCursor = end + MARKDOWN_CLOSING_FENCE.length;
-    searchCursor = summaryCursor;
-  }
-  summaryParts.push(content.slice(summaryCursor));
-  return { summary: summaryParts.join("").trim(), products };
-}
-function createChatService(options) {
-  const {
-    conversationsUrl = DEFAULT_AI_CHAT_CONVERSATIONS_URL,
-    messagesUrl = DEFAULT_AI_CHAT_MESSAGES_URL,
-    salesAiAppKey,
-    salesAiParentOrigin,
-    market,
-    language,
-    fetchImpl: fetchImplOption
-  } = options;
-  let fetchImpl;
-  if (fetchImplOption !== void 0) {
-    fetchImpl = fetchImplOption;
-  } else if (typeof fetch === "function") {
-    fetchImpl = fetch.bind(globalThis);
-  } else {
-    fetchImpl = () => {
-      throw new Error("ChatService: no fetch implementation available");
-    };
-  }
-  function buildHeaders(extra, includeJsonContentType = true) {
-    const headers = {
-      ...extra
-    };
-    if (includeJsonContentType) {
-      headers["Content-Type"] = "application/json";
-    }
-    const accessToken = typeof window !== "undefined" ? window.localStorage?.getItem("accessToken") : null;
-    if (accessToken) {
-      headers["Authorization"] = `Bearer ${accessToken}`;
-    }
-    if (salesAiAppKey) {
-      headers["X-Sales-AI-App-Key"] = salesAiAppKey;
-    }
-    if (salesAiParentOrigin) {
-      headers["X-Sales-AI-Parent-Origin"] = salesAiParentOrigin;
-    }
-    return headers;
-  }
-  return {
-    async createConversation() {
-      const res = await fetchImpl(conversationsUrl, {
-        method: "POST",
-        headers: buildHeaders(void 0, false)
-      });
-      if (!res.ok) {
-        throw new Error(
-          `ChatService.createConversation: ${res.status} ${res.statusText}`
-        );
-      }
-      const data = await res.json();
-      const id = data["id"] ?? data["conversation_id"];
-      if (typeof id !== "number") {
-        throw new TypeError(
-          "ChatService.createConversation: response missing numeric id"
-        );
-      }
-      return id;
-    },
-    async sendMessage(conversationId, content, onChunk) {
-      const requestBody = {
-        conversation_id: conversationId,
-        content
-      };
-      if (market || language) {
-        requestBody.scope_context = {
-          market: market ?? "US",
-          language: language ?? "en"
-        };
-      }
-      requestBody.client_capabilities = {
-        patterns: {
-          product_list: [1],
-          follow_up: [1]
-        }
-      };
-      const res = await fetchImpl(messagesUrl, {
-        method: "POST",
-        headers: buildHeaders({ Accept: "text/event-stream" }),
-        body: JSON.stringify(requestBody)
-      });
-      if (!res.ok) {
-        throw new Error(
-          `ChatService.sendMessage: ${res.status} ${res.statusText}`
-        );
-      }
-      let accumulated = "";
-      const renderedProducts = [];
-      const parser = createParser({
-        onEvent(event) {
-          const data = event.data;
-          if (!data || data === "[DONE]") return;
-          try {
-            const parsed = JSON.parse(data);
-            const parsedType = parsed["type"];
-            const type = typeof parsedType === "string" ? parsedType : "";
-            renderedProducts.push(
-              ...getRenderProductListItems(parsed)
-            );
-            if (type === "content" && typeof parsed["text"] === "string") {
-              const text = parsed["text"];
-              accumulated += text;
-              onChunk?.(type, text);
-            } else if (type === "status" && typeof parsed["message"] === "string") {
-              const message = parsed["message"];
-              onChunk?.(type, message);
-            }
-          } catch {
-          }
-        }
-      });
-      const body = res.body;
-      if (body && typeof body.getReader === "function") {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          parser.feed(decoder.decode(value, { stream: true }));
-        }
-        parser.feed(decoder.decode());
-      } else {
-        const rawBody = await res.text();
-        parser.feed(rawBody);
-      }
-      const { summary, products } = extractProductsFromMarkdown(accumulated);
-      const finalProducts = renderedProducts.length > 0 ? renderedProducts : products;
-      return {
-        summary,
-        products: finalProducts,
-        rawContent: accumulated
-      };
-    }
-  };
-}
-
 // src/utils/catalogHelpers.ts
 var CART_DISABLED_PRODUCT_STATUSES = /* @__PURE__ */ new Set([
   "discontinued",
@@ -1249,37 +701,42 @@ function useSearchSuggestions({
   service,
   enabled = true
 }) {
-  const [query, setQuery] = React.useState("");
-  const [suggestions, setSuggestions] = React.useState([]);
-  const [didYouMean, setDidYouMean] = React.useState([]);
-  const [loading, setLoading] = React.useState(false);
-  const [emptyFetched, setEmptyFetched] = React.useState(false);
-  const [hasMoreResults, setHasMoreResults] = React.useState(false);
-  const [totalResultsCount, setTotalResultsCount] = React.useState(0);
-  const fetchDebounced = React.useRef(null);
-  const latestRequestId = React.useRef(0);
-  const resetSuggestionsState = React.useCallback(() => {
+  const [query, setQuery] = react.useState("");
+  const [suggestions, setSuggestions] = react.useState([]);
+  const [didYouMean, setDidYouMean] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [emptyFetched, setEmptyFetched] = react.useState(false);
+  const [suggestionFetchFailed, setSuggestionFetchFailed] = react.useState(false);
+  const [hasMoreResults, setHasMoreResults] = react.useState(false);
+  const [totalResultsCount, setTotalResultsCount] = react.useState(0);
+  const [settledQuery, setSettledQuery] = react.useState("");
+  const fetchDebounced = react.useRef(null);
+  const latestRequestId = react.useRef(0);
+  const resetSuggestionsState = react.useCallback(() => {
     setSuggestions([]);
     setDidYouMean([]);
     setEmptyFetched(false);
+    setSuggestionFetchFailed(false);
     setHasMoreResults(false);
     setTotalResultsCount(0);
+    setSettledQuery("");
     setLoading(false);
   }, []);
-  const updateQuery = React.useCallback(
+  const updateQuery = react.useCallback(
     (nextQuery) => {
       const hasNextQuery = Boolean(nextQuery.trim());
       setEmptyFetched(false);
+      setSuggestionFetchFailed(false);
       setLoading(enabled && hasNextQuery);
       setQuery(nextQuery);
     },
     [enabled]
   );
-  const clearQuery = React.useCallback(() => {
+  const clearQuery = react.useCallback(() => {
     resetSuggestionsState();
     setQuery("");
   }, [resetSuggestionsState]);
-  const runFetch = React.useCallback(
+  const runFetch = react.useCallback(
     async (nextQuery) => {
       const trimmedQuery = nextQuery.trim();
       const requestId = latestRequestId.current;
@@ -1289,6 +746,7 @@ function useSearchSuggestions({
       }
       setLoading(true);
       setEmptyFetched(false);
+      setSuggestionFetchFailed(false);
       try {
         const fetchedSuggestions = await service.fetchSuggestions(trimmedQuery);
         if (requestId !== latestRequestId.current) {
@@ -1311,6 +769,8 @@ function useSearchSuggestions({
           !hasDidYouMean && effectiveTotal > MAX_VISIBLE_SUGGESTIONS
         );
         setTotalResultsCount(effectiveTotal);
+        setSuggestionFetchFailed(false);
+        setSettledQuery(trimmedQuery);
         setEmptyFetched(
           hasDidYouMean ? false : visibleSuggestions.length === 0 && suggestedTerms.length === 0
         );
@@ -1321,8 +781,10 @@ function useSearchSuggestions({
         setSuggestions([]);
         setDidYouMean([]);
         setEmptyFetched(true);
+        setSuggestionFetchFailed(true);
         setHasMoreResults(false);
         setTotalResultsCount(0);
+        setSettledQuery(trimmedQuery);
       } finally {
         if (requestId === latestRequestId.current) {
           setLoading(false);
@@ -1331,7 +793,7 @@ function useSearchSuggestions({
     },
     [enabled, service, resetSuggestionsState]
   );
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (!enabled) {
       resetSuggestionsState();
       return void 0;
@@ -1357,419 +819,625 @@ function useSearchSuggestions({
     didYouMean,
     loading,
     query,
+    settledQuery,
     setQuery,
+    suggestionFetchFailed,
     suggestions,
     totalResultsCount,
     updateQuery
   };
 }
 
-// node_modules/zustand/esm/vanilla.mjs
-var createStoreImpl = (createState) => {
-  let state;
-  const listeners = /* @__PURE__ */ new Set();
-  const setState = (partial, replace) => {
-    const nextState = typeof partial === "function" ? partial(state) : partial;
-    if (!Object.is(nextState, state)) {
-      const previousState = state;
-      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
-      listeners.forEach((listener) => listener(state, previousState));
-    }
-  };
-  const getState = () => state;
-  const getInitialState = () => initialState;
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    return () => listeners.delete(listener);
-  };
-  const api = { setState, getState, getInitialState, subscribe };
-  const initialState = state = createState(setState, getState, api);
-  return api;
+// src/utils/gtmConstants.ts
+var SEARCH_GTM_EVENTS = {
+  CHAT_ENTRY_POINT: "Begin_chat",
+  SEARCH_TYPE: "Search_Type",
+  PRODUCT_SEARCH: "ProductSearch",
+  ERROR_POPUP: "Error_popup"
 };
-var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
-var identity = (arg) => arg;
-function useStore(api, selector = identity) {
-  const slice = React__default.default.useSyncExternalStore(
-    api.subscribe,
-    () => selector(api.getState()),
-    () => selector(api.getInitialState())
-  );
-  React__default.default.useDebugValue(slice);
-  return slice;
-}
-var createImpl = (createState) => {
-  const api = createStore(createState);
-  const useBoundStore = (selector) => useStore(api, selector);
-  Object.assign(useBoundStore, api);
-  return useBoundStore;
+var SEARCH_GTM_SEARCH_TYPES = {
+  SEMANTIC: "semantic search",
+  AI_AGENT: "AI agent"
+};
+var SEARCH_GTM_USER_STATUS = {
+  GUEST: "guest",
+  LOGGED_IN: "logged_in"
 };
-var create = (createState) => createImpl;
+var IS_AUTHENTICATED_KEY = "IsAuthenticated";
+var ACCOUNT_TYPE_KEY = "accountType";
+var NUSKIN_ACCOUNT_DATA_KEY = "nuskin.account.data";
+var GTM_FALLBACK_NA = "NA";
 
-// node_modules/zustand/esm/middleware.mjs
-function createJSONStorage(getStorage, options) {
-  let storage;
+// src/utils/commonUtils.ts
+var IS_BROWSER = typeof window !== "undefined";
+function toEventString(value, fallback = " ") {
+  if (value === void 0 || value === null) return fallback;
+  const str = String(value).trim();
+  return str.length > 0 ? str : fallback;
+}
+function getLocaleFromUrl(pathname) {
+  const path = pathname ?? (IS_BROWSER ? window.location.pathname : "");
+  const [country, language] = path.split("/").filter(Boolean);
+  if (!/^[a-z]{2}$/i.test(country ?? "") || !/^[a-z]{2}$/i.test(language ?? "")) {
+    return {};
+  }
+  return {
+    countryCode: country.toUpperCase(),
+    language: language.toLowerCase()
+  };
+}
+function safeParse(raw) {
   try {
-    storage = getStorage();
-  } catch (e) {
-    return;
+    return JSON.parse(raw);
+  } catch {
+    return raw;
   }
-  const persistStorage = {
-    getItem: (name) => {
-      var _a;
-      const parse = (str2) => {
-        if (str2 === null) {
-          return null;
-        }
-        return JSON.parse(str2, void 0 );
-      };
-      const str = (_a = storage.getItem(name)) != null ? _a : null;
-      if (str instanceof Promise) {
-        return str.then(parse);
-      }
-      return parse(str);
-    },
-    setItem: (name, newValue) => storage.setItem(
-      name,
-      JSON.stringify(newValue, void 0 )
+}
+function getLocalStorage(key) {
+  if (!IS_BROWSER) return void 0;
+  try {
+    const raw = window.localStorage.getItem(key);
+    return raw === null ? void 0 : safeParse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/gtmTracking.ts
+function readUserStatusFromStorage() {
+  const value = getLocalStorage(IS_AUTHENTICATED_KEY);
+  if (value === void 0) return void 0;
+  if (value === SEARCH_GTM_USER_STATUS.GUEST || value === SEARCH_GTM_USER_STATUS.LOGGED_IN) {
+    return value;
+  }
+  const isAuthenticated = value === true || typeof value === "string" && ["true", "1", "yes", "y"].includes(value.toLowerCase().trim());
+  return isAuthenticated ? SEARCH_GTM_USER_STATUS.LOGGED_IN : SEARCH_GTM_USER_STATUS.GUEST;
+}
+function readAccountTypeFromStorage() {
+  const value = getLocalStorage(ACCOUNT_TYPE_KEY);
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readUserIdFromStorage() {
+  const raw = getLocalStorage(NUSKIN_ACCOUNT_DATA_KEY);
+  if (!raw || typeof raw !== "object") return void 0;
+  const user = raw.user;
+  if (!user || typeof user !== "object") return void 0;
+  const id = user.id;
+  return typeof id === "string" && id.trim().length > 0 ? id : void 0;
+}
+function resolveUserId(explicit) {
+  return toEventString(explicit ?? readUserIdFromStorage(), GTM_FALLBACK_NA);
+}
+function baseEventPayload(ctx) {
+  const urlLocale = getLocaleFromUrl();
+  const userStatus = ctx.userStatus ?? readUserStatusFromStorage();
+  const accountType = ctx.accountType ?? readAccountTypeFromStorage();
+  const resolvedUserStatus = userStatus ?? SEARCH_GTM_USER_STATUS.GUEST;
+  const documentTitle = IS_BROWSER && typeof document?.title === "string" ? document.title : void 0;
+  return {
+    Chat_ID: toEventString(ctx.chatId, GTM_FALLBACK_NA),
+    page_type: toEventString(
+      ctx.pageType ?? documentTitle,
+      GTM_FALLBACK_NA
+    ),
+    country_code: toEventString(
+      ctx.countryCode ?? urlLocale.countryCode,
+      GTM_FALLBACK_NA
+    ),
+    language: toEventString(
+      ctx.language ?? urlLocale.language,
+      GTM_FALLBACK_NA
+    ),
+    user_status: toEventString(
+      resolvedUserStatus,
+      SEARCH_GTM_USER_STATUS.GUEST
     ),
-    removeItem: (name) => storage.removeItem(name)
+    account_type: toEventString(accountType, GTM_FALLBACK_NA)
   };
-  return persistStorage;
 }
-var toThenable = (fn) => (input) => {
+function serializeProductResults(productResultsData, productResults) {
+  if (productResultsData !== void 0) {
+    try {
+      return JSON.stringify(productResultsData);
+    } catch {
+      return GTM_FALLBACK_NA;
+    }
+  }
+  if (productResults === void 0 || productResults === null) {
+    return GTM_FALLBACK_NA;
+  }
+  return String(productResults);
+}
+function pushGtmEvent(event) {
+  if (!IS_BROWSER) return;
   try {
-    const result = fn(input);
-    if (result instanceof Promise) {
-      return result;
+    const layer = window.dataLayer ?? (window.dataLayer = []);
+    layer.push(event);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[react-search-sdk] pushGtmEvent failed:", err);
     }
-    return {
-      then(onFulfilled) {
-        return toThenable(onFulfilled)(result);
-      },
-      catch(_onRejected) {
-        return this;
-      }
-    };
-  } catch (e) {
-    return {
-      then(_onFulfilled) {
-        return this;
-      },
-      catch(onRejected) {
-        return toThenable(onRejected)(e);
-      }
-    };
   }
-};
-var persistImpl = (config, baseOptions) => (set, get, api) => {
-  let options = {
-    storage: createJSONStorage(() => localStorage),
-    partialize: (state) => state,
-    version: 0,
-    merge: (persistedState, currentState) => ({
-      ...currentState,
-      ...persistedState
-    }),
-    ...baseOptions
-  };
-  let hasHydrated = false;
-  const hydrationListeners = /* @__PURE__ */ new Set();
-  const finishHydrationListeners = /* @__PURE__ */ new Set();
-  let storage = options.storage;
-  if (!storage) {
-    return config(
-      (...args) => {
-        console.warn(
-          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
-        );
-        set(...args);
-      },
-      get,
-      api
+}
+function trackChatEntryPoint(ctx) {
+  pushGtmEvent({
+    event: SEARCH_GTM_EVENTS.CHAT_ENTRY_POINT,
+    ...baseEventPayload(ctx)
+  });
+}
+function trackSearchType(input) {
+  pushGtmEvent({
+    event: SEARCH_GTM_EVENTS.SEARCH_TYPE,
+    ...baseEventPayload(input),
+    id: resolveUserId(input.userId),
+    type: input.searchType ?? SEARCH_GTM_SEARCH_TYPES.SEMANTIC,
+    search_response: toEventString(input.searchResponse, GTM_FALLBACK_NA)
+  });
+}
+function trackProductSearch(input) {
+  pushGtmEvent({
+    event: SEARCH_GTM_EVENTS.PRODUCT_SEARCH,
+    ...baseEventPayload(input),
+    id: resolveUserId(input.userId),
+    search_type: input.searchType ?? SEARCH_GTM_SEARCH_TYPES.SEMANTIC,
+    Product_results: serializeProductResults(
+      input.productResultsData,
+      input.productResults
+    )
+  });
+}
+function trackErrorPopup(input) {
+  pushGtmEvent({
+    event: SEARCH_GTM_EVENTS.ERROR_POPUP,
+    ...baseEventPayload(input),
+    id: resolveUserId(input.userId),
+    search_type: input.searchType ?? SEARCH_GTM_SEARCH_TYPES.SEMANTIC
+  });
+}
+
+// src/utils/nuiSearchGate.ts
+var NUI_SEARCH_FLAG = "enableNuiSearch";
+function parseFlagValue(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
+function readCookieFlag(cookie) {
+  for (const part of cookie.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (part.slice(0, separator).trim() !== NUI_SEARCH_FLAG) continue;
+    const rawValue = part.slice(separator + 1);
+    try {
+      return parseFlagValue(decodeURIComponent(rawValue));
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function resolveNuiSearchFlag(env = {}) {
+  const inBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  const search = env.search ?? (inBrowser ? window.location.search : "");
+  const cookie = env.cookie ?? (inBrowser ? document.cookie : "");
+  const setCookie = env.setCookie ?? (inBrowser ? (value) => {
+    document.cookie = value;
+  } : void 0);
+  const fromQuery = parseFlagValue(
+    new URLSearchParams(search).get(NUI_SEARCH_FLAG)
+  );
+  if (fromQuery !== void 0) {
+    const secure = inBrowser && window.location.protocol === "https:" ? "; Secure" : "";
+    setCookie?.(
+      `${NUI_SEARCH_FLAG}=${fromQuery}; path=/; SameSite=Lax${secure}`
     );
+    return fromQuery;
   }
-  const setItem = () => {
-    const state = options.partialize({ ...get() });
-    return storage.setItem(options.name, {
-      state,
-      version: options.version
-    });
-  };
-  const savedSetState = api.setState;
-  api.setState = (state, replace) => {
-    savedSetState(state, replace);
-    void setItem();
-  };
-  const configResult = config(
-    (...args) => {
-      set(...args);
-      void setItem();
+  return readCookieFlag(cookie);
+}
+function isNuiSearchEnabled({
+  isAuthenticated,
+  flag
+}) {
+  return isAuthenticated === true && flag === true;
+}
+
+// src/utils/searchRouting.ts
+function decideSearchRoute({
+  enabled,
+  snapshot
+}) {
+  const term = snapshot.query.trim();
+  if (!enabled || !term) return "search";
+  if (snapshot.loading || snapshot.settledQuery !== term) return "wait";
+  if (snapshot.suggestionFetchFailed) return "search";
+  return snapshot.suggestions.length > 0 ? "search" : "handoff";
+}
+var HANDLE_POLL_MS = 50;
+var HANDLE_TIMEOUT_MS = 15e3;
+var SalesAIChatWidget = react.lazy(async () => {
+  const [widget] = await Promise.all([
+    import('@nuskin/react-nui-chat-sdk'),
+    import('@nuskin/react-nui-chat-sdk/styles.css')
+  ]);
+  return { default: widget.SalesAIChatWidget };
+});
+function getSalesAIHandle() {
+  return window.SalesAI;
+}
+var AgentErrorBoundary = class extends react.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { failed: false };
+  }
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(_error, _info) {
+    this.props.onError();
+  }
+  render() {
+    return this.state.failed ? null : this.props.children;
+  }
+};
+function useHandoff({
+  query,
+  handoffContext,
+  agentContext,
+  onUnavailable
+}) {
+  react.useEffect(() => {
+    let cancelled = false;
+    let timer;
+    const startedAt = Date.now();
+    const tryOpen = () => {
+      if (cancelled) return;
+      const handle = getSalesAIHandle();
+      if (handle) {
+        handle.open({
+          query,
+          context: { ...agentContext, ...handoffContext }
+        });
+        return;
+      }
+      if (Date.now() - startedAt >= HANDLE_TIMEOUT_MS) {
+        onUnavailable();
+        return;
+      }
+      timer = setTimeout(tryOpen, HANDLE_POLL_MS);
+    };
+    tryOpen();
+    return () => {
+      cancelled = true;
+      if (timer !== void 0) clearTimeout(timer);
+    };
+  }, [query]);
+}
+function NuiAgentPanel({
+  agent,
+  query,
+  handoffContext,
+  onUnavailable
+}) {
+  useHandoff({
+    query,
+    handoffContext,
+    agentContext: agent.context,
+    onUnavailable
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(AgentErrorBoundary, { onError: onUnavailable, children: /* @__PURE__ */ jsxRuntime.jsx(react.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsx(
+    SalesAIChatWidget,
+    {
+      appKey: agent.appKey,
+      apiBaseUrl: agent.apiBaseUrl,
+      theme: agent.theme ?? "nui-light",
+      defaultOpen: true,
+      hideFab: true,
+      placement: "host",
+      ...agent.language === void 0 ? {} : { language: agent.language },
+      ...agent.renderProduct === void 0 ? {} : { renderProduct: agent.renderProduct }
+    }
+  ) }) });
+}
+var SUBMIT_WAIT_TIMEOUT_MS = 2e3;
+function uniqueRecentSearches(queries) {
+  const seen = /* @__PURE__ */ new Set();
+  return queries.filter((query) => {
+    const key = query.trim().toLowerCase();
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function ProductSearch({
+  isOpen,
+  onClose,
+  service,
+  navigate,
+  isAuthenticated,
+  agent,
+  logo,
+  cancelLabel,
+  fallbackImageUrl,
+  copy,
+  gtmContext
+}) {
+  const [flag, setFlag] = react.useState(void 0);
+  const [handoff, setHandoff] = react.useState(null);
+  const agentQuery = handoff?.query ?? null;
+  const [pendingTerm, setPendingTerm] = react.useState(null);
+  const [recentSearches, setRecentSearches] = react.useState([]);
+  const search = useSearchSuggestions({
+    service,
+    enabled: isOpen && agentQuery === null
+  });
+  const {
+    clearQuery,
+    didYouMean,
+    emptyFetched,
+    hasMoreResults,
+    loading,
+    query,
+    settledQuery,
+    suggestionFetchFailed,
+    suggestions,
+    updateQuery
+  } = search;
+  const enabled = isNuiSearchEnabled({ isAuthenticated, flag });
+  const items = getVisibleSuggestions({
+    didYouMean,
+    suggestions
+  });
+  const showDidYouMean = didYouMean.length > 0;
+  react.useEffect(() => {
+    if (isOpen) setFlag(resolveNuiSearchFlag());
+  }, [isOpen]);
+  react.useEffect(() => {
+    if (isOpen) {
+      setRecentSearches(
+        uniqueRecentSearches(service.getRecentSearches())
+      );
+    }
+  }, [isOpen, service, agentQuery]);
+  const close = react.useCallback(() => {
+    setHandoff(null);
+    setPendingTerm(null);
+    clearQuery();
+    onClose();
+  }, [clearQuery, onClose]);
+  react.useEffect(() => {
+    if (!isOpen) {
+      setHandoff(null);
+      setPendingTerm(null);
+      clearQuery();
+    }
+  }, [isOpen, clearQuery]);
+  const navigateTo = react.useCallback(
+    (path) => {
+      if (!path || path === "action-handled" || path === "action-pending") {
+        return;
+      }
+      navigate(path);
+      close();
     },
-    get,
-    api
+    [navigate, close]
   );
-  api.getInitialState = () => configResult;
-  let stateFromStorage;
-  const hydrate = () => {
-    var _a, _b;
-    if (!storage) return;
-    hasHydrated = false;
-    hydrationListeners.forEach((cb) => {
-      var _a2;
-      return cb((_a2 = get()) != null ? _a2 : configResult);
-    });
-    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
-    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
-      if (deserializedStorageValue) {
-        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
-          if (options.migrate) {
-            return [
-              true,
-              options.migrate(
-                deserializedStorageValue.state,
-                deserializedStorageValue.version
-              )
-            ];
-          }
-          console.error(
-            `State loaded from storage couldn't be migrated since no migrate function was provided`
-          );
-        } else {
-          return [false, deserializedStorageValue.state];
-        }
+  const trackSemantic = react.useCallback(
+    (productResultsData) => {
+      trackProductSearch({
+        ...gtmContext,
+        searchType: SEARCH_GTM_SEARCH_TYPES.SEMANTIC,
+        productResultsData
+      });
+    },
+    [gtmContext]
+  );
+  const runSearch = react.useCallback(
+    (term) => {
+      trackSemantic(items.length > 0 ? items : { query: term });
+      navigateTo(service.submitProductSearch(term));
+    },
+    [items, navigateTo, service, trackSemantic]
+  );
+  const decide = react.useCallback(
+    (term) => decideSearchRoute({
+      enabled,
+      snapshot: {
+        query: term,
+        loading,
+        settledQuery,
+        suggestions,
+        suggestionFetchFailed
       }
-      return [false, void 0];
-    }).then((migrationResult) => {
-      var _a2;
-      const [migrated, migratedState] = migrationResult;
-      stateFromStorage = options.merge(
-        migratedState,
-        (_a2 = get()) != null ? _a2 : configResult
-      );
-      set(stateFromStorage, true);
-      if (migrated) {
-        return setItem();
+    }),
+    [enabled, loading, settledQuery, suggestions, suggestionFetchFailed]
+  );
+  const act = react.useCallback(
+    (term, route) => {
+      setPendingTerm(null);
+      if (route === "handoff") {
+        trackChatEntryPoint(gtmContext ?? {});
+        setHandoff({
+          query: term,
+          didYouMean: didYouMean.map((item) => item.value)
+        });
+        return;
       }
-    }).then(() => {
-      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
-      stateFromStorage = get();
-      hasHydrated = true;
-      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
-    }).catch((e) => {
-      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
-    });
-  };
-  api.persist = {
-    setOptions: (newOptions) => {
-      options = {
-        ...options,
-        ...newOptions
-      };
-      if (newOptions.storage) {
-        storage = newOptions.storage;
+      runSearch(term);
+    },
+    [didYouMean, gtmContext, runSearch]
+  );
+  const handleSubmit = react.useCallback(
+    (value) => {
+      const term = value.trim();
+      if (!term) return;
+      const route = decide(term);
+      if (route === "wait") {
+        setPendingTerm(term);
+        return;
       }
+      act(term, route);
     },
-    clearStorage: () => {
-      storage == null ? void 0 : storage.removeItem(options.name);
+    [act, decide]
+  );
+  const latest = react.useRef({ act, decide });
+  latest.current = { act, decide };
+  react.useEffect(() => {
+    if (pendingTerm === null) return void 0;
+    const route = latest.current.decide(pendingTerm);
+    if (route !== "wait") {
+      latest.current.act(pendingTerm, route);
+      return void 0;
+    }
+    const timer = setTimeout(
+      () => latest.current.act(pendingTerm, "search"),
+      SUBMIT_WAIT_TIMEOUT_MS
+    );
+    return () => clearTimeout(timer);
+  }, [
+    pendingTerm,
+    loading,
+    settledQuery,
+    suggestions,
+    suggestionFetchFailed
+  ]);
+  const handleSelect = react.useCallback(
+    (option) => {
+      if (isSuggestionDisabled(
+        option
+      )) {
+        return;
+      }
+      const term = String(option["value"] ?? option["label"] ?? "");
+      if (term.trim()) trackSemantic([option]);
+      const suggestionOption = option;
+      const href = service.getSuggestionHref(suggestionOption);
+      navigateTo(
+        href || service.submitProductSearch(term, suggestionOption)
+      );
     },
-    getOptions: () => options,
-    rehydrate: () => hydrate(),
-    hasHydrated: () => hasHydrated,
-    onHydrate: (cb) => {
-      hydrationListeners.add(cb);
-      return () => {
-        hydrationListeners.delete(cb);
-      };
+    [navigateTo, service, trackSemantic]
+  );
+  const handleRunAction = react.useCallback(
+    (option) => {
+      if (isSuggestionDisabled(
+        option
+      )) {
+        return;
+      }
+      const result = service.activateSuggestionAction(
+        option
+      );
+      void Promise.resolve(result).then(navigateTo).catch(() => void 0);
     },
-    onFinishHydration: (cb) => {
-      finishHydrationListeners.add(cb);
-      return () => {
-        finishHydrationListeners.delete(cb);
-      };
-    }
-  };
-  if (!options.skipHydration) {
-    hydrate();
-  }
-  return stateFromStorage || configResult;
-};
-var persist = persistImpl;
-
-// src/store/searchHistoryStore.ts
-var MAX_HISTORY = 10;
-var useSearchHistoryStore = create()(
-  persist(
-    (set) => ({
-      entries: [],
-      addEntry: (entry) => {
-        const trimmed = entry.query.trim();
-        if (!trimmed) return;
-        set((state) => {
-          const deduped = state.entries.filter(
-            (e) => e.query.toLowerCase() !== trimmed.toLowerCase()
-          );
-          const newEntry = {
-            ...entry,
-            query: trimmed,
-            timestamp: Date.now()
-          };
-          return {
-            entries: [newEntry, ...deduped].slice(0, MAX_HISTORY)
-          };
-        });
+    [navigateTo, service]
+  );
+  const handleSeeMore = react.useCallback(() => {
+    const term = query.trim();
+    if (term) navigateTo(service.viewMoreResults({ query: term }));
+  }, [navigateTo, query, service]);
+  const handleRecentSelect = react.useCallback(
+    (recentQuery) => {
+      trackSemantic({ query: recentQuery });
+      navigateTo(service.submitProductSearch(recentQuery));
+    },
+    [navigateTo, service, trackSemantic]
+  );
+  const handleClearRecent = react.useCallback(() => {
+    service.clearRecentSearches();
+    setRecentSearches([]);
+  }, [service]);
+  const handleAgentUnavailable = react.useCallback(() => {
+    if (agentQuery !== null)
+      navigateTo(service.submitProductSearch(agentQuery));
+  }, [agentQuery, navigateTo, service]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactSearchComponents.SearchModal,
+    {
+      isOpen,
+      onClose: close,
+      logo,
+      ...cancelLabel === void 0 ? {} : { cancelLabel },
+      ...fallbackImageUrl === void 0 ? {} : { fallbackImageUrl },
+      ...copy === void 0 ? {} : { copy },
+      input: {
+        value: query,
+        onChange: updateQuery,
+        onSubmit: handleSubmit
       },
-      addQuery: (query) => {
-        const trimmed = query.trim();
-        if (!trimmed) return;
-        set((state) => {
-          const deduped = state.entries.filter(
-            (e) => e.query.toLowerCase() !== trimmed.toLowerCase()
-          );
-          return {
-            entries: [
-              {
-                query: trimmed,
-                isAI: false,
-                timestamp: Date.now()
-              },
-              ...deduped
-            ].slice(0, MAX_HISTORY)
-          };
-        });
+      suggestions: {
+        items,
+        loading,
+        showNoResults: !loading && emptyFetched && items.length === 0,
+        showDidYouMean,
+        hasMore: hasMoreResults,
+        query,
+        onSelect: handleSelect,
+        onRunAction: handleRunAction,
+        onSeeMore: handleSeeMore
       },
-      removeEntry: (query) => set((state) => ({
-        entries: state.entries.filter((e) => e.query !== query)
-      })),
-      clearAll: () => set({ entries: [] })
-    }),
-    {
-      name: "ai_search_recent_queries",
-      version: 1,
-      storage: createJSONStorage(
-        () => typeof window !== "undefined" ? window.sessionStorage : {}
-      ),
-      // Migrate from v0 (queries: string[]) to v1 (entries: SearchHistoryEntry[])
-      migrate(persistedState, version) {
-        if (version === 0) {
-          const old = persistedState;
-          if (Array.isArray(old?.queries)) {
-            return {
-              entries: old.queries.map((q) => ({
-                query: q,
-                isAI: false,
-                timestamp: Date.now()
-              }))
-            };
-          }
+      recentSearches: {
+        items: recentSearches,
+        onSelect: handleRecentSelect,
+        onClear: handleClearRecent
+      },
+      agentPanel: handoff === null ? void 0 : /* @__PURE__ */ jsxRuntime.jsx(
+        NuiAgentPanel,
+        {
+          agent,
+          query: handoff.query,
+          handoffContext: {
+            source: "storefront_search",
+            trigger: "zero_results",
+            query: handoff.query,
+            did_you_mean: handoff.didYouMean
+          },
+          onUnavailable: handleAgentUnavailable
         }
-        return persistedState;
-      }
+      )
     }
-  )
-);
-
-// src/hooks/useSearchHistory.ts
-function useSearchHistory() {
-  const entries = useSearchHistoryStore((s) => s.entries);
-  const addEntry = useSearchHistoryStore((s) => s.addEntry);
-  const addQuery = useSearchHistoryStore((s) => s.addQuery);
-  const removeEntry = useSearchHistoryStore((s) => s.removeEntry);
-  const clearAll = useSearchHistoryStore((s) => s.clearAll);
-  return {
-    entries,
-    queries: entries.map((e) => e.query),
-    addEntry,
-    addQuery,
-    removeEntry,
-    clearAll
-  };
-}
-function getSpeechRecognition() {
-  if (typeof window === "undefined") return null;
-  const w = window;
-  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
-}
-function useVoiceSearch({
-  lang,
-  onInterimResult,
-  onResult,
-  onError
-}) {
-  const [listening, setListening] = React.useState(false);
-  const recognitionRef = React.useRef(null);
-  const supported = getSpeechRecognition() !== null;
-  const stop = React.useCallback(() => {
-    recognitionRef.current?.stop();
-    recognitionRef.current = null;
-    setListening(false);
-  }, []);
-  const start = React.useCallback(() => {
-    const SR = getSpeechRecognition();
-    if (!SR) return;
-    stop();
-    const rec = new SR();
-    rec.lang = lang ?? navigator.language ?? "en-US";
-    rec.interimResults = true;
-    rec.maxAlternatives = 1;
-    rec.onresult = (event) => {
-      let finalTranscript = "";
-      let interimTranscript = "";
-      const startIndex = event.resultIndex ?? 0;
-      for (let index = startIndex; index < event.results.length; index += 1) {
-        const result = event.results[index];
-        const transcript = result?.[0]?.transcript ?? "";
-        if (!transcript) continue;
-        if (result?.isFinal) {
-          finalTranscript += transcript;
-        } else {
-          interimTranscript += transcript;
-        }
-      }
-      if (interimTranscript) onInterimResult?.(interimTranscript);
-      if (finalTranscript) onResult(finalTranscript);
-    };
-    rec.onerror = (event) => {
-      onError?.(event);
-      setListening(false);
-    };
-    rec.onend = () => setListening(false);
-    recognitionRef.current = rec;
-    rec.start();
-    setListening(true);
-  }, [lang, onInterimResult, onResult, onError, stop]);
-  return { listening, supported, start, stop };
+  );
 }
 
 exports.CATALOG_SUGGESTIONS_PATH = CATALOG_SUGGESTIONS_PATH;
 exports.DEBOUNCE_MS = DEBOUNCE_MS;
-exports.DEFAULT_AI_CHAT_BASE_URL = DEFAULT_AI_CHAT_BASE_URL;
-exports.DEFAULT_AI_CHAT_CONVERSATIONS_URL = DEFAULT_AI_CHAT_CONVERSATIONS_URL;
-exports.DEFAULT_AI_CHAT_MESSAGES_URL = DEFAULT_AI_CHAT_MESSAGES_URL;
 exports.DEFAULT_SEARCH_PATH = DEFAULT_SEARCH_PATH;
 exports.DEFAULT_SUGGESTION_PAGE = DEFAULT_SUGGESTION_PAGE;
 exports.DEFAULT_SUGGESTION_SIZE = DEFAULT_SUGGESTION_SIZE;
 exports.MAX_VISIBLE_SUGGESTIONS = MAX_VISIBLE_SUGGESTIONS;
+exports.NUI_SEARCH_FLAG = NUI_SEARCH_FLAG;
+exports.ProductSearch = ProductSearch;
 exports.RECENT_SEARCHES_DEFAULT_LIMIT = RECENT_SEARCHES_DEFAULT_LIMIT;
 exports.RECENT_SEARCHES_PREFIX = RECENT_SEARCHES_PREFIX;
+exports.SEARCH_GTM_EVENTS = SEARCH_GTM_EVENTS;
+exports.SEARCH_GTM_SEARCH_TYPES = SEARCH_GTM_SEARCH_TYPES;
+exports.SEARCH_GTM_USER_STATUS = SEARCH_GTM_USER_STATUS;
 exports.SEARCH_PLACEHOLDER = SEARCH_PLACEHOLDER;
 exports.STOREFRONT_SHOPPING_CONTEXT = STOREFRONT_SHOPPING_CONTEXT;
+exports.SUBMIT_WAIT_TIMEOUT_MS = SUBMIT_WAIT_TIMEOUT_MS;
 exports.TRIGGER_PLACEHOLDER = TRIGGER_PLACEHOLDER;
-exports.createChatService = createChatService;
 exports.createSearchService = createSearchService;
+exports.decideSearchRoute = decideSearchRoute;
 exports.getImageFromProperty = getImageFromProperty;
 exports.getIngredientTerms = getIngredientTerms;
+exports.getLocaleFromUrl = getLocaleFromUrl;
 exports.getSeeMoreResultsPayload = getSeeMoreResultsPayload;
 exports.getVisibleSuggestions = getVisibleSuggestions;
 exports.isCartActionDisabled = isCartActionDisabled;
+exports.isNuiSearchEnabled = isNuiSearchEnabled;
 exports.isSellableProductStatus = isSellableProductStatus;
 exports.isSuggestionDisabled = isSuggestionDisabled;
 exports.mapCatalogProductToSuggestion = mapCatalogProductToSuggestion;
 exports.normalizeDidYouMean = normalizeDidYouMean;
+exports.pushGtmEvent = pushGtmEvent;
 exports.resolveApiGatewayPath = resolveApiGatewayPath;
+exports.resolveNuiSearchFlag = resolveNuiSearchFlag;
 exports.resolveSuggestionImageSrc = resolveSuggestionImageSrc;
-exports.useSearchHistory = useSearchHistory;
-exports.useSearchHistoryStore = useSearchHistoryStore;
+exports.trackChatEntryPoint = trackChatEntryPoint;
+exports.trackErrorPopup = trackErrorPopup;
+exports.trackProductSearch = trackProductSearch;
+exports.trackSearchType = trackSearchType;
 exports.useSearchSuggestions = useSearchSuggestions;
-exports.useVoiceSearch = useVoiceSearch;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map