@commerce-ai-tool/react 2.4.0

package/dist/index.js

@@ -0,0 +1,3702 @@
+"use client";
+
+// src/components/CommerceAISearch.tsx
+import { useCallback as useCallback5, useMemo as useMemo3, useRef as useRef7, useState as useState8 } from "react";
+import {
+  Camera as Camera2,
+  Check as Check2,
+  ImageIcon,
+  Mic,
+  Package as Package3,
+  Search,
+  SearchX as SearchX2,
+  ShoppingCart as ShoppingCart2,
+  Square,
+  Volume2
+} from "lucide-react";
+
+// ../core/dist/client.js
+var CART_SESSION_HEADER = "x-commerce-ai-cart-session";
+var DEFAULT_COMMERCE_AI_SEARCH_MESSAGES = {
+  placeholder: "What are you looking for?",
+  searchAriaLabel: "Search query",
+  productSearchAriaLabel: "Product search",
+  searchResultsAriaLabel: "Search results",
+  searching: "Searching...",
+  noProductsFound: "No products found",
+  searchedFor: "Searched for:",
+  dropImageToSearch: "Drop image to search",
+  voiceSearch: "Voice search",
+  stopRecording: "Stop recording",
+  searchByCamera: "Search by camera",
+  searchByImage: "Search by image",
+  replayVoiceSummary: "Replay voice result summary",
+  listening: "Listening\u2026",
+  tapMicToStop: "Tap mic to stop",
+  understandingQuery: "Understanding your query\u2026",
+  preparingAudioSummary: "Preparing audio summary\u2026",
+  cameraCapture: "Camera capture",
+  cameraPreview: "Camera preview",
+  capturePhoto: "Capture",
+  cancel: "Cancel",
+  dismiss: "Dismiss",
+  searchFailed: "Search failed",
+  imageSearchFailed: "Image search failed",
+  couldNotCapturePhoto: "Could not capture photo",
+  suggestionsAriaLabel: "Search suggestions",
+  loadingSuggestions: "Loading suggestions...",
+  noSuggestions: "No suggestions",
+  filtersAriaLabel: "Search filters",
+  clearFilters: "Clear filters",
+  narrowResults: "Narrow your results",
+  newSearch: "New search",
+  addToCart: "Add to cart",
+  cart: "Cart",
+  emptyCart: "Your cart is empty",
+  removeItem: "Remove item",
+  total: "Total",
+  each: "each",
+  cartAriaLabel: "Shopping cart",
+  itemAdded: "Added to cart",
+  increaseQuantity: "Increase quantity",
+  decreaseQuantity: "Decrease quantity",
+  closeCart: "Close cart",
+  unableToAddToCart: "This product cannot be added to the cart",
+  missionTitle: "Shopping list",
+  missionQuantity: "Looking for",
+  missionAddAll: "Add {count} top picks to cart",
+  missionItemsAdded: "Added to cart",
+  missionSelectProduct: "Select this product",
+  missionIntentEmpty: "No matching products",
+  missionIntentFailed: "Couldn't search this item",
+  signIn: "Sign in",
+  signInToSyncCart: "Sign in to sync your cart",
+  signOut: "Sign out",
+  email: "Email",
+  password: "Password",
+  signedInAs: "Signed in as",
+  invalidCredentials: "Invalid email or password",
+  signInFailed: "Sign in failed",
+  checkout: "Checkout",
+  checkoutTitle: "Complete your order",
+  orderSummary: "Order summary",
+  shippingAddress: "Shipping address",
+  billingAddress: "Billing address",
+  billingSameAsShipping: "Billing address is the same as shipping",
+  continueToDelivery: "Continue to delivery",
+  shippingMethod: "Delivery method",
+  selectShippingMethod: "Select a delivery method",
+  noShippingMethods: "No delivery methods are available for this address",
+  completeAddressToContinue: "Add a shipping address to continue",
+  selectDeliveryToContinue: "Select a delivery method to continue",
+  selectPaymentToContinue: "Select a payment method to continue",
+  checkoutStepAddress: "Address",
+  checkoutStepDelivery: "Delivery",
+  checkoutStepPayment: "Payment",
+  paymentMethod: "Payment method",
+  selectPaymentMethod: "Select a payment method",
+  paymentAuthorized: "Payment authorized",
+  paymentDeclined: "Payment was declined",
+  continueToPayment: "Continue to payment",
+  placeOrder: "Place order",
+  placingOrder: "Placing order\u2026",
+  orderPlaced: "Order placed",
+  viewOrderStatus: "View order status",
+  continueShopping: "Continue shopping",
+  checkoutFailed: "Checkout failed",
+  orderStatus: "Order status",
+  orderPlacedAt: "Placed",
+  paymentStateLabel: "Payment",
+  shipmentStateLabel: "Shipment",
+  trackingNumber: "Tracking number",
+  carrier: "Carrier",
+  noTrackingYet: "Tracking details will appear when the order ships",
+  orderNotFound: "Order not found",
+  noOrdersYet: "No orders yet",
+  yourOrders: "Your orders",
+  firstName: "First name",
+  lastName: "Last name",
+  streetName: "Street address",
+  additionalAddress: "Apartment, suite, etc. (optional)",
+  postalCode: "Postal code",
+  city: "City",
+  region: "State or region (optional)",
+  country: "Country"
+};
+function resolveCommerceAISearchMessages(overrides) {
+  return {
+    ...DEFAULT_COMMERCE_AI_SEARCH_MESSAGES,
+    ...overrides
+  };
+}
+var COMPOUND_SHOPPING_LIST_PATTERN = /\band\b|,|\bplus\b|\boraz\b/i;
+function looksLikeCompoundShoppingList(query) {
+  return COMPOUND_SHOPPING_LIST_PATTERN.test(query.trim());
+}
+var CSS_NAMED_COLOR_TABLE = `
+Alice Blue:f0f8ff
+Antique White:faebd7
+Aqua:00ffff
+Aquamarine:7fffd4
+Azure:f0ffff
+Beige:f5f5dc
+Bisque:ffe4c4
+Black:000000
+Blanched Almond:ffebcd
+Blue:0000ff
+Blue Violet:8a2be2
+Brown:a52a2a
+Burlywood:deb887
+Cadet Blue:5f9ea0
+Chartreuse:7fff00
+Chocolate:d2691e
+Coral:ff7f50
+Cornflower Blue:6495ed
+Cornsilk:fff8dc
+Crimson:dc143c
+Dark Blue:00008b
+Dark Cyan:008b8b
+Dark Goldenrod:b8860b
+Dark Gray:a9a9a9
+Dark Green:006400
+Dark Khaki:bdb76b
+Dark Magenta:8b008b
+Dark Olive Green:556b2f
+Dark Orange:ff8c00
+Dark Orchid:9932cc
+Dark Red:8b0000
+Dark Salmon:e9967a
+Dark Sea Green:8fbc8f
+Dark Slate Blue:483d8b
+Dark Slate Gray:2f4f4f
+Dark Turquoise:00ced1
+Dark Violet:9400d3
+Deep Pink:ff1493
+Deep Sky Blue:00bfff
+Dim Gray:696969
+Dodger Blue:1e90ff
+Firebrick:b22222
+Floral White:fffaf0
+Forest Green:228b22
+Gainsboro:dcdcdc
+Ghost White:f8f8ff
+Gold:ffd700
+Goldenrod:daa520
+Gray:808080
+Green:008000
+Green Yellow:adff2f
+Honeydew:f0fff0
+Hot Pink:ff69b4
+Indian Red:cd5c5c
+Indigo:4b0082
+Ivory:fffff0
+Khaki:f0e68c
+Lavender:e6e6fa
+Lavender Blush:fff0f5
+Lawn Green:7cfc00
+Lemon Chiffon:fffacd
+Light Blue:add8e6
+Light Coral:f08080
+Light Cyan:e0ffff
+Light Goldenrod Yellow:fafad2
+Light Gray:d3d3d3
+Light Green:90ee90
+Light Pink:ffb6c1
+Light Salmon:ffa07a
+Light Sea Green:20b2aa
+Light Sky Blue:87cefa
+Light Slate Gray:778899
+Light Steel Blue:b0c4de
+Light Yellow:ffffe0
+Lime:00ff00
+Lime Green:32cd32
+Linen:faf0e6
+Magenta:ff00ff
+Maroon:800000
+Medium Aquamarine:66cdaa
+Medium Blue:0000cd
+Medium Orchid:ba55d3
+Medium Purple:9370db
+Medium Sea Green:3cb371
+Medium Slate Blue:7b68ee
+Medium Spring Green:00fa9a
+Medium Turquoise:48d1cc
+Medium Violet Red:c71585
+Midnight Blue:191970
+Mint Cream:f5fffa
+Misty Rose:ffe4e1
+Moccasin:ffe4b5
+Navajo White:ffdead
+Navy:000080
+Old Lace:fdf5e6
+Olive:808000
+Olive Drab:6b8e23
+Orange:ffa500
+Orange Red:ff4500
+Orchid:da70d6
+Pale Goldenrod:eee8aa
+Pale Green:98fb98
+Pale Turquoise:afeeee
+Pale Violet Red:db7093
+Papaya Whip:ffefd5
+Peach Puff:ffdab9
+Peru:cd853f
+Pink:ffc0cb
+Plum:dda0dd
+Powder Blue:b0e0e6
+Purple:800080
+Rebecca Purple:663399
+Red:ff0000
+Rosy Brown:bc8f8f
+Royal Blue:4169e1
+Saddle Brown:8b4513
+Salmon:fa8072
+Sandy Brown:f4a460
+Sea Green:2e8b57
+Seashell:fff5ee
+Sienna:a0522d
+Silver:c0c0c0
+Sky Blue:87ceeb
+Slate Blue:6a5acd
+Slate Gray:708090
+Snow:fffafa
+Spring Green:00ff7f
+Steel Blue:4682b4
+Tan:d2b48c
+Teal:008080
+Thistle:d8bfd8
+Tomato:ff6347
+Turquoise:40e0d0
+Violet:ee82ee
+Wheat:f5deb3
+White:ffffff
+White Smoke:f5f5f5
+Yellow:ffff00
+Yellow Green:9acd32
+`;
+var HEX_COLOR_RE = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var NAMED_COLORS = CSS_NAMED_COLOR_TABLE.trim().split("\n").flatMap((line) => {
+  const separator = line.indexOf(":");
+  if (separator <= 0) {
+    return [];
+  }
+  const name = line.slice(0, separator);
+  const hex = line.slice(separator + 1);
+  const n = Number.parseInt(hex, 16);
+  if (!name || !Number.isFinite(n)) {
+    return [];
+  }
+  return [{ name, r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 }];
+});
+function parseHexRgb(value) {
+  const match = HEX_COLOR_RE.exec(value.trim());
+  const captured = match?.[1];
+  if (!captured) {
+    return null;
+  }
+  const hex = captured.length === 3 ? `${captured[0]}${captured[0]}${captured[1]}${captured[1]}${captured[2]}${captured[2]}` : captured;
+  const n = Number.parseInt(hex, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+var MAX_NAMED_COLOR_DISTANCE_SQ = 40 * 40;
+var COLOR_LIKE_FACET_NAME = /(?:^|[-_])colou?r(?:[-_]|$)|(?:^|[-_])finish(?:[-_]|$)/i;
+function isColorLikeFacetName(name) {
+  return COLOR_LIKE_FACET_NAME.test(name.trim());
+}
+function hexColorSwatchValue(value) {
+  const rgb = parseHexRgb(value);
+  if (!rgb) {
+    return void 0;
+  }
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+var PRICE_FACET_ID = "price";
+var CATEGORIES_FACET_ID = "categories";
+var DEFAULT_PRICE_RANGES = [
+  { key: "under-50", to: 5e3 },
+  { key: "50-to-100", from: 5e3, to: 1e4 },
+  { key: "100-plus", from: 1e4 }
+];
+function priceRangeToFilterValues(range) {
+  const filters = {};
+  if ("from" in range && range.from !== void 0) {
+    filters.priceMin = String(range.from / 100);
+  }
+  if ("to" in range && range.to !== void 0) {
+    filters.priceMax = String(range.to / 100);
+  }
+  return filters;
+}
+function priceBucketKeyFromFilters(filters) {
+  const minCents = parseMajorToCents(filters.priceMin);
+  const maxCents = parseMajorToCents(filters.priceMax);
+  for (const range of DEFAULT_PRICE_RANGES) {
+    const from = "from" in range ? range.from : void 0;
+    const to = "to" in range ? range.to : void 0;
+    if (minCents === from && maxCents === to) {
+      return range.key;
+    }
+  }
+  return void 0;
+}
+function isFacetFilterSelected(filters, facetId, bucketKey) {
+  if (facetId === CATEGORIES_FACET_ID) {
+    return filters.category === bucketKey;
+  }
+  if (facetId === PRICE_FACET_ID) {
+    return priceBucketKeyFromFilters(filters) === bucketKey;
+  }
+  return filters[facetId] === bucketKey;
+}
+function toggleFacetFilter(filters, facetId, bucketKey) {
+  const next = { ...filters };
+  if (facetId === PRICE_FACET_ID) {
+    if (priceBucketKeyFromFilters(next) === bucketKey) {
+      delete next.priceMin;
+      delete next.priceMax;
+      return next;
+    }
+    delete next.priceMin;
+    delete next.priceMax;
+    const range = DEFAULT_PRICE_RANGES.find((candidate) => candidate.key === bucketKey);
+    if (!range) {
+      return next;
+    }
+    return { ...next, ...priceRangeToFilterValues(range) };
+  }
+  const filterKey = facetId === CATEGORIES_FACET_ID ? "category" : facetId;
+  if (next[filterKey] === bucketKey) {
+    delete next[filterKey];
+  } else {
+    next[filterKey] = bucketKey;
+  }
+  return next;
+}
+function parseMajorToCents(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return Math.round(parsed * 100);
+}
+
+// src/hooks/useCommerceAISearch.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+function buildLocalePayload(options) {
+  const payload = {};
+  const queryLocale = options.queryLocale ?? options.locale;
+  if (options.catalogLocale) {
+    payload.catalogLocale = options.catalogLocale;
+  }
+  if (queryLocale) {
+    payload.queryLocale = queryLocale;
+  }
+  return payload;
+}
+function appendLocaleFields(formData, options) {
+  const payload = buildLocalePayload(options);
+  for (const [key, value] of Object.entries(payload)) {
+    formData.append(key, value);
+  }
+}
+function useCommerceAISearch(options) {
+  const {
+    apiBaseUrl,
+    debounceMs = 250,
+    suggestionsDebounceMs = 200,
+    enableAutocomplete = false,
+    enableFacets = false,
+    persistSession = true,
+    enableMissions = false,
+    queryLocale,
+    catalogLocale,
+    locale
+  } = options;
+  const localePayload = useMemo(
+    () => buildLocalePayload({ queryLocale, catalogLocale, locale }),
+    [queryLocale, catalogLocale, locale]
+  );
+  const [query, setQueryState] = useState("");
+  const [suggestions, setSuggestions] = useState([]);
+  const [isLoadingSuggestions, setIsLoadingSuggestions] = useState(false);
+  const [suggestionsError, setSuggestionsError] = useState(null);
+  const [suggestionsReady, setSuggestionsReady] = useState(false);
+  const [results, setResults] = useState([]);
+  const [mission, setMission] = useState(null);
+  const [meta, setMeta] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [hasSearched, setHasSearched] = useState(false);
+  const [error, setError] = useState(null);
+  const [facets, setFacets] = useState([]);
+  const [suggestedFacets, setSuggestedFacets] = useState([]);
+  const [searchSession, setSearchSession] = useState(null);
+  const debounceRef = useRef(null);
+  const suggestionsDebounceRef = useRef(null);
+  const abortRef = useRef(null);
+  const suggestionsAbortRef = useRef(null);
+  const requestIdRef = useRef(0);
+  const suggestionsRequestIdRef = useRef(0);
+  const queryRef = useRef(query);
+  queryRef.current = query;
+  const baseUrl = apiBaseUrl.replace(/\/$/, "");
+  const sessionStorageKey = `cat:search-session:${baseUrl}`;
+  useEffect(() => {
+    if (!enableFacets || !persistSession || typeof window === "undefined") return;
+    const stored = window.sessionStorage.getItem(sessionStorageKey);
+    if (!stored) return;
+    try {
+      setSearchSession(JSON.parse(stored));
+    } catch {
+      window.sessionStorage.removeItem(sessionStorageKey);
+    }
+  }, [enableFacets, persistSession, sessionStorageKey]);
+  useEffect(() => {
+    if (!enableFacets || !persistSession || !searchSession || typeof window === "undefined") return;
+    window.sessionStorage.setItem(sessionStorageKey, JSON.stringify(searchSession));
+  }, [enableFacets, persistSession, searchSession, sessionStorageKey]);
+  const resetResults = useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    suggestionsAbortRef.current?.abort();
+    suggestionsAbortRef.current = null;
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+      debounceRef.current = null;
+    }
+    if (suggestionsDebounceRef.current) {
+      clearTimeout(suggestionsDebounceRef.current);
+      suggestionsDebounceRef.current = null;
+    }
+    setResults([]);
+    setMission(null);
+    setMeta(null);
+    setError(null);
+    setIsLoading(false);
+    setHasSearched(false);
+    setSuggestions([]);
+    setSuggestionsError(null);
+    setIsLoadingSuggestions(false);
+    setSuggestionsReady(false);
+    setFacets([]);
+    setSuggestedFacets([]);
+    setSearchSession(null);
+    if (typeof window !== "undefined") {
+      window.sessionStorage.removeItem(sessionStorageKey);
+    }
+  }, [sessionStorageKey]);
+  const fetchSuggestions = useCallback(
+    async (searchQuery) => {
+      const trimmed = searchQuery.trim();
+      if (!enableAutocomplete || trimmed.length < 2) {
+        setSuggestions([]);
+        setSuggestionsError(null);
+        setIsLoadingSuggestions(false);
+        setSuggestionsReady(false);
+        return;
+      }
+      suggestionsAbortRef.current?.abort();
+      const controller = new AbortController();
+      suggestionsAbortRef.current = controller;
+      const requestId = ++suggestionsRequestIdRef.current;
+      setIsLoadingSuggestions(true);
+      setSuggestionsError(null);
+      setSuggestionsReady(false);
+      try {
+        const response = await fetch(`${baseUrl}/search/suggestions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: trimmed, ...localePayload }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const data2 = await response.json();
+          throw new Error(data2.error ?? "Suggestions failed");
+        }
+        const data = await response.json();
+        if (requestId !== suggestionsRequestIdRef.current) return;
+        setSuggestions(data.suggestions);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (requestId !== suggestionsRequestIdRef.current) return;
+        setSuggestions([]);
+        setSuggestionsError(err instanceof Error ? err.message : "Suggestions failed");
+      } finally {
+        if (requestId === suggestionsRequestIdRef.current) {
+          setIsLoadingSuggestions(false);
+          setSuggestionsReady(true);
+        }
+      }
+    },
+    [baseUrl, enableAutocomplete, localePayload]
+  );
+  const applySearchResult = useCallback(
+    (data, sessionQuery) => {
+      setResults(data.products);
+      setMission(data.mission ?? null);
+      setMeta(data.meta);
+      setFacets(data.facets ?? []);
+      setSuggestedFacets(data.suggestedFacets ?? []);
+      if (data.mission) {
+        setSearchSession(null);
+        if (typeof window !== "undefined") {
+          window.sessionStorage.removeItem(sessionStorageKey);
+        }
+      } else if (enableFacets && data.meta.searchTerms) {
+        setSearchSession({
+          query: sessionQuery?.trim() || queryRef.current || data.meta.queryInterpretation || "",
+          searchTerms: data.meta.searchTerms,
+          appliedFilters: data.meta.appliedFilters ?? {},
+          suggestedFacets: data.suggestedFacets ?? [],
+          facetSchema: data.facetSchema,
+          schemaEtag: data.meta.schemaEtag
+        });
+      }
+    },
+    [enableFacets, sessionStorageKey]
+  );
+  const search = useCallback(
+    async (searchQuery) => {
+      const q = (searchQuery ?? queryRef.current).trim();
+      if (!q) return;
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
+      if (suggestionsDebounceRef.current) {
+        clearTimeout(suggestionsDebounceRef.current);
+        suggestionsDebounceRef.current = null;
+      }
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const requestId = ++requestIdRef.current;
+      setIsLoading(true);
+      setError(null);
+      setResults([]);
+      setMission(null);
+      setMeta(null);
+      setSuggestions([]);
+      setSuggestionsError(null);
+      try {
+        const response = await fetch(`${baseUrl}/search`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            query: q,
+            includeFacets: enableFacets,
+            ...enableMissions ? { enableMissions: true } : {},
+            ...localePayload
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const data2 = await response.json();
+          throw new Error(data2.error ?? "Search failed");
+        }
+        const data = await response.json();
+        if (requestId !== requestIdRef.current) return;
+        applySearchResult(data, q);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (requestId !== requestIdRef.current) return;
+        setError(err instanceof Error ? err.message : "Search failed");
+        setResults([]);
+        setMission(null);
+        setMeta(null);
+      } finally {
+        if (requestId === requestIdRef.current) {
+          setIsLoading(false);
+          setHasSearched(true);
+        }
+      }
+    },
+    [applySearchResult, baseUrl, enableFacets, enableMissions, localePayload]
+  );
+  const submitRefinement = useCallback(
+    async (body) => {
+      if (!searchSession) return;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const requestId = ++requestIdRef.current;
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(`${baseUrl}/search`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            query: searchSession.query,
+            searchTerms: searchSession.searchTerms,
+            filters: body.filters ?? searchSession.appliedFilters,
+            refineQuery: body.refineQuery,
+            suggestedFacets: searchSession.suggestedFacets,
+            includeFacets: true,
+            ...localePayload
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const data2 = await response.json();
+          throw new Error(data2.error ?? "Search refinement failed");
+        }
+        const data = await response.json();
+        if (requestId !== requestIdRef.current) return;
+        applySearchResult(data, searchSession.query);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (requestId === requestIdRef.current) {
+          setError(err instanceof Error ? err.message : "Search refinement failed");
+        }
+      } finally {
+        if (requestId === requestIdRef.current) {
+          setIsLoading(false);
+          setHasSearched(true);
+        }
+      }
+    },
+    [applySearchResult, baseUrl, localePayload, searchSession]
+  );
+  const refineFilters = useCallback(
+    async (filters) => submitRefinement({ filters }),
+    [submitRefinement]
+  );
+  const refine = useCallback(
+    async (refineQuery) => {
+      const trimmed = refineQuery.trim();
+      if (trimmed) await submitRefinement({ refineQuery: trimmed });
+    },
+    [submitRefinement]
+  );
+  const startNewSearch = useCallback(async () => {
+    const previousQuery = searchSession?.query;
+    const q = (queryRef.current.trim() || previousQuery || "").trim();
+    setSearchSession(null);
+    setFacets([]);
+    setSuggestedFacets([]);
+    if (typeof window !== "undefined") {
+      window.sessionStorage.removeItem(sessionStorageKey);
+    }
+    if (q) {
+      if (!queryRef.current.trim() && previousQuery) {
+        setQueryState(previousQuery);
+      }
+      await search(q);
+    }
+  }, [search, searchSession?.query, sessionStorageKey]);
+  const searchByImage = useCallback(
+    async (file) => {
+      abortRef.current?.abort();
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
+      if (suggestionsDebounceRef.current) {
+        clearTimeout(suggestionsDebounceRef.current);
+        suggestionsDebounceRef.current = null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setResults([]);
+      setMission(null);
+      setMeta(null);
+      setSuggestions([]);
+      try {
+        const formData = new FormData();
+        formData.append("image", file);
+        appendLocaleFields(formData, { queryLocale, catalogLocale, locale });
+        if (enableMissions) {
+          formData.append("enableMissions", "true");
+        }
+        const response = await fetch(`${baseUrl}/search/image`, {
+          method: "POST",
+          body: formData
+        });
+        if (!response.ok) {
+          const data2 = await response.json();
+          throw new Error(data2.error ?? "Image search failed");
+        }
+        const data = await response.json();
+        applySearchResult(data, data.interpretation);
+        if (data.interpretation) {
+          setQueryState(data.interpretation);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Image search failed");
+        setResults([]);
+        setMission(null);
+        setMeta(null);
+      } finally {
+        setIsLoading(false);
+        setHasSearched(true);
+      }
+    },
+    [applySearchResult, baseUrl, catalogLocale, enableMissions, locale, queryLocale]
+  );
+  const setQuery = useCallback(
+    (value, options2) => {
+      setQueryState(value);
+      if (options2?.search === false) {
+        if (debounceRef.current) {
+          clearTimeout(debounceRef.current);
+          debounceRef.current = null;
+        }
+        if (suggestionsDebounceRef.current) {
+          clearTimeout(suggestionsDebounceRef.current);
+          suggestionsDebounceRef.current = null;
+        }
+        return;
+      }
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+      if (suggestionsDebounceRef.current) clearTimeout(suggestionsDebounceRef.current);
+      const trimmed = value.trim();
+      if (trimmed.length === 0 || trimmed.length < 2) {
+        resetResults();
+        return;
+      }
+      if (enableAutocomplete) {
+        setResults([]);
+        setMission(null);
+        setError(null);
+        setIsLoading(false);
+        setHasSearched(false);
+        setIsLoadingSuggestions(true);
+        setSuggestionsError(null);
+        suggestionsDebounceRef.current = setTimeout(() => {
+          void fetchSuggestions(trimmed);
+        }, suggestionsDebounceMs);
+        return;
+      }
+      setIsLoading(true);
+      setError(null);
+      setResults([]);
+      setMission(null);
+      setMeta(null);
+      debounceRef.current = setTimeout(() => {
+        void search(trimmed);
+      }, debounceMs);
+    },
+    [debounceMs, enableAutocomplete, fetchSuggestions, resetResults, search, suggestionsDebounceMs]
+  );
+  const selectSuggestion = useCallback(
+    (suggestion) => {
+      setQueryState(suggestion);
+      setSuggestions([]);
+      setSuggestionsError(null);
+      void search(suggestion);
+    },
+    [search]
+  );
+  const clear = useCallback(() => {
+    setQueryState("");
+    resetResults();
+  }, [resetResults]);
+  return {
+    query,
+    setQuery,
+    suggestions,
+    isLoadingSuggestions,
+    suggestionsError,
+    suggestionsReady,
+    selectSuggestion,
+    results,
+    setResults,
+    mission,
+    setMission,
+    meta,
+    setMeta,
+    isLoading,
+    setIsLoading,
+    hasSearched,
+    setHasSearched,
+    error,
+    setError,
+    search,
+    searchByImage,
+    facets,
+    suggestedFacets,
+    hasFacetSession: searchSession !== null,
+    refineFilters,
+    refine,
+    startNewSearch,
+    applySearchResult,
+    clear
+  };
+}
+
+// src/hooks/useCameraCapture.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/utils/camera.ts
+function prefersNativeCamera() {
+  if (typeof navigator === "undefined") return false;
+  return /Android|iPhone|iPad|iPod/i.test(navigator.userAgent) || navigator.maxTouchPoints > 1 && matchMedia("(pointer: coarse)").matches;
+}
+function stopMediaStream(stream) {
+  stream?.getTracks().forEach((track) => track.stop());
+}
+function getCameraErrorMessage(error) {
+  if (error instanceof DOMException) {
+    if (error.name === "NotAllowedError" || error.name === "PermissionDeniedError") {
+      return "Camera access denied";
+    }
+    if (error.name === "NotFoundError" || error.name === "DevicesNotFoundError") {
+      return "No camera found";
+    }
+    if (error.name === "NotReadableError" || error.name === "TrackStartError") {
+      return "Camera is already in use";
+    }
+  }
+  return "Camera unavailable";
+}
+function createJpegFileFromVideo(video, fileName = "camera-capture.jpg") {
+  const width = video.videoWidth;
+  const height = video.videoHeight;
+  if (!width || !height) {
+    return Promise.reject(new Error("Camera preview is not ready"));
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return Promise.reject(new Error("Could not capture photo"));
+  }
+  context.drawImage(video, 0, 0, width, height);
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => {
+        if (!blob) {
+          reject(new Error("Could not capture photo"));
+          return;
+        }
+        resolve(new File([blob], fileName, { type: "image/jpeg" }));
+      },
+      "image/jpeg",
+      0.92
+    );
+  });
+}
+function buildCameraConstraints(facingMode) {
+  return {
+    video: {
+      facingMode: { ideal: facingMode },
+      width: { ideal: 1920 },
+      height: { ideal: 1080 }
+    },
+    audio: false
+  };
+}
+
+// src/hooks/useCameraCapture.ts
+function useCameraCapture(options = {}) {
+  const facingMode = options.facingMode ?? "environment";
+  const [isOpen, setIsOpen] = useState2(false);
+  const [stream, setStream] = useState2(null);
+  const [error, setError] = useState2(null);
+  const streamRef = useRef2(null);
+  const close = useCallback2(() => {
+    stopMediaStream(streamRef.current);
+    streamRef.current = null;
+    setStream(null);
+    setIsOpen(false);
+  }, []);
+  const clearError = useCallback2(() => {
+    setError(null);
+  }, []);
+  const openOverlay = useCallback2(async () => {
+    setError(null);
+    try {
+      const mediaStream = await navigator.mediaDevices.getUserMedia(
+        buildCameraConstraints(facingMode)
+      );
+      streamRef.current = mediaStream;
+      setStream(mediaStream);
+      setIsOpen(true);
+    } catch (err) {
+      setError(getCameraErrorMessage(err));
+      close();
+    }
+  }, [close, facingMode]);
+  const open = useCallback2(
+    (nativeInputRef) => {
+      setError(null);
+      if (prefersNativeCamera()) {
+        nativeInputRef.current?.click();
+        return;
+      }
+      void openOverlay();
+    },
+    [openOverlay]
+  );
+  const capturePhoto = useCallback2(
+    async (video) => {
+      const file = await createJpegFileFromVideo(video);
+      close();
+      return file;
+    },
+    [close]
+  );
+  useEffect2(() => {
+    return () => {
+      stopMediaStream(streamRef.current);
+      streamRef.current = null;
+    };
+  }, []);
+  return {
+    isOpen,
+    stream,
+    error,
+    facingMode,
+    open,
+    openOverlay,
+    capturePhoto,
+    close,
+    clearError
+  };
+}
+
+// src/hooks/useCart.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+var ANONYMOUS_ID_STORAGE_KEY = "commerce-ai-tool:anonymousId";
+var CUSTOMER_SESSION_STORAGE_KEY = "commerce-ai-tool:customerSession";
+var CUSTOMER_STORAGE_KEY = "commerce-ai-tool:customer";
+function readStorage(key) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeStorage(key, value) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function removeStorage(key) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    window.localStorage.removeItem(key);
+  } catch {
+  }
+}
+function readStoredCustomer() {
+  const raw = readStorage(CUSTOMER_STORAGE_KEY);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.id === "string" && typeof parsed.email === "string") {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function createAnonymousId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `anon-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getOrCreateAnonymousId() {
+  const existing = readStorage(ANONYMOUS_ID_STORAGE_KEY);
+  if (existing) {
+    return existing;
+  }
+  const created = createAnonymousId();
+  writeStorage(ANONYMOUS_ID_STORAGE_KEY, created);
+  return created;
+}
+function rotateAnonymousId() {
+  const created = createAnonymousId();
+  writeStorage(ANONYMOUS_ID_STORAGE_KEY, created);
+  return created;
+}
+var cartSyncListeners = /* @__PURE__ */ new Set();
+var cartSyncSeq = 0;
+function emitCartSync(sourceId, cart) {
+  for (const listener of cartSyncListeners) {
+    listener(sourceId, cart);
+  }
+}
+var CartRequestError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "CartRequestError";
+    this.status = status;
+  }
+};
+async function parseCartApi(response) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new CartRequestError(body.error ?? "Cart request failed", response.status);
+  }
+  return body;
+}
+function useCart(options) {
+  const {
+    apiBaseUrl,
+    currency,
+    country,
+    catalogLocale,
+    enabled = true,
+    onCartChange
+  } = options;
+  const [anonymousId, setAnonymousId] = useState3("");
+  const [sessionToken, setSessionToken] = useState3(null);
+  const [customer, setCustomer] = useState3(null);
+  const [cart, setCart] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [isMutating, setIsMutating] = useState3(false);
+  const [isLoggingIn, setIsLoggingIn] = useState3(false);
+  const [error, setError] = useState3(null);
+  const [isCartOpen, setIsCartOpen] = useState3(false);
+  const onCartChangeRef = useRef3(onCartChange);
+  onCartChangeRef.current = onCartChange;
+  const cartRef = useRef3(null);
+  const sessionTokenRef = useRef3(null);
+  const mutationChainRef = useRef3(Promise.resolve(void 0));
+  const orderNumberRef = useRef3(null);
+  const [syncId] = useState3(() => {
+    cartSyncSeq += 1;
+    return cartSyncSeq;
+  });
+  const applyCart = useCallback3((next, sync = true) => {
+    cartRef.current = next;
+    setCart(next);
+    onCartChangeRef.current?.(next);
+    if (sync) {
+      emitCartSync(syncId, next);
+    }
+  }, [syncId]);
+  const persistSession = useCallback3((token, nextCustomer) => {
+    sessionTokenRef.current = token;
+    setSessionToken(token);
+    setCustomer(nextCustomer);
+    writeStorage(CUSTOMER_SESSION_STORAGE_KEY, token);
+    writeStorage(CUSTOMER_STORAGE_KEY, JSON.stringify(nextCustomer));
+  }, []);
+  const clearSession = useCallback3(() => {
+    sessionTokenRef.current = null;
+    setSessionToken(null);
+    setCustomer(null);
+    removeStorage(CUSTOMER_SESSION_STORAGE_KEY);
+    removeStorage(CUSTOMER_STORAGE_KEY);
+  }, []);
+  const refresh = useCallback3(async () => {
+    if (!enabled || !anonymousId) {
+      return;
+    }
+    const params = new URLSearchParams();
+    const headers = {};
+    const token = sessionTokenRef.current;
+    if (token) {
+      headers[CART_SESSION_HEADER] = token;
+    } else {
+      params.set("anonymousId", anonymousId);
+    }
+    if (catalogLocale) {
+      params.set("catalogLocale", catalogLocale);
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const query = params.toString();
+      const url = `${apiBaseUrl}/cart${query ? `?${query}` : ""}`;
+      const response = await (token ? fetch(url, { headers }) : fetch(url));
+      const body = await parseCartApi(response);
+      applyCart(body.cart ?? null);
+    } catch (err) {
+      if (err instanceof CartRequestError && err.status === 401 && sessionTokenRef.current) {
+        clearSession();
+        const nextAnonymousId = rotateAnonymousId();
+        setAnonymousId(nextAnonymousId);
+        applyCart(null);
+      }
+      setError(err instanceof Error ? err.message : "Cart request failed");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [anonymousId, apiBaseUrl, applyCart, catalogLocale, clearSession, enabled]);
+  useEffect3(() => {
+    if (!enabled) {
+      return;
+    }
+    setAnonymousId(getOrCreateAnonymousId());
+    const storedToken = readStorage(CUSTOMER_SESSION_STORAGE_KEY);
+    const storedCustomer = readStoredCustomer();
+    if (storedToken && storedCustomer) {
+      sessionTokenRef.current = storedToken;
+      setSessionToken(storedToken);
+      setCustomer(storedCustomer);
+    }
+  }, [enabled]);
+  useEffect3(() => {
+    if (!enabled) {
+      return;
+    }
+    const listener = (sourceId, next) => {
+      if (sourceId === syncId) {
+        return;
+      }
+      applyCart(next, false);
+    };
+    cartSyncListeners.add(listener);
+    return () => {
+      cartSyncListeners.delete(listener);
+    };
+  }, [applyCart, enabled, syncId]);
+  useEffect3(() => {
+    if (!enabled || !anonymousId) {
+      return;
+    }
+    void refresh();
+  }, [anonymousId, enabled, refresh]);
+  const mutate = useCallback3(
+    async (path, body) => {
+      if (!enabled || !anonymousId) {
+        return null;
+      }
+      const run = async () => {
+        setIsMutating(true);
+        setError(null);
+        try {
+          const response = await fetch(`${apiBaseUrl}${path}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              anonymousId,
+              sessionToken: sessionTokenRef.current ?? void 0,
+              currency,
+              country,
+              catalogLocale,
+              cartId: cartRef.current?.id,
+              cartVersion: cartRef.current?.version,
+              ...body
+            })
+          });
+          const next = await parseCartApi(response);
+          applyCart(next.cart ?? null);
+          return next.cart ?? null;
+        } catch (err) {
+          if (err instanceof CartRequestError && err.status === 401 && sessionTokenRef.current) {
+            clearSession();
+            setAnonymousId(rotateAnonymousId());
+            applyCart(null);
+          }
+          setError(err instanceof Error ? err.message : "Cart request failed");
+          return null;
+        } finally {
+          setIsMutating(false);
+        }
+      };
+      const pending = mutationChainRef.current.then(run, run);
+      mutationChainRef.current = pending.then(
+        () => void 0,
+        () => void 0
+      );
+      return pending;
+    },
+    [anonymousId, apiBaseUrl, applyCart, catalogLocale, clearSession, country, currency, enabled]
+  );
+  const addToCart = useCallback3(
+    async (item) => mutate("/cart/add", {
+      sku: item.sku,
+      productId: item.productId,
+      variantId: item.variantId,
+      quantity: item.quantity
+    }),
+    [mutate]
+  );
+  const addItems = useCallback3(
+    async (items) => mutate("/cart/add-items", { items }),
+    [mutate]
+  );
+  const removeFromCart = useCallback3(
+    (lineItemId) => mutate("/cart/remove", { lineItemId }),
+    [mutate]
+  );
+  const updateQuantity = useCallback3(
+    (lineItemId, quantity) => mutate("/cart/update-quantity", { lineItemId, quantity }),
+    [mutate]
+  );
+  const setAddresses = useCallback3(
+    (shippingAddress, billingAddress) => mutate("/cart/addresses", { shippingAddress, billingAddress }),
+    [mutate]
+  );
+  const getShippingMethods = useCallback3(async () => {
+    if (!enabled || !anonymousId) {
+      return [];
+    }
+    const params = new URLSearchParams();
+    const headers = {};
+    const token = sessionTokenRef.current;
+    if (token) {
+      headers[CART_SESSION_HEADER] = token;
+    } else {
+      params.set("anonymousId", anonymousId);
+    }
+    if (cartRef.current?.id) {
+      params.set("cartId", cartRef.current.id);
+    }
+    if (catalogLocale) {
+      params.set("catalogLocale", catalogLocale);
+    }
+    setIsMutating(true);
+    setError(null);
+    try {
+      const response = await fetch(
+        `${apiBaseUrl}/cart/shipping-methods?${params.toString()}`,
+        token ? { headers } : void 0
+      );
+      const body = await parseCartApi(response);
+      return body.shippingMethods ?? [];
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Shipping methods request failed");
+      return null;
+    } finally {
+      setIsMutating(false);
+    }
+  }, [anonymousId, apiBaseUrl, catalogLocale, enabled]);
+  const setShippingMethod = useCallback3(
+    (shippingMethodId) => mutate("/cart/shipping-method", { shippingMethodId }),
+    [mutate]
+  );
+  const getPaymentMethods = useCallback3(async () => {
+    if (!enabled || !anonymousId) {
+      return [];
+    }
+    const params = new URLSearchParams();
+    const headers = {};
+    const token = sessionTokenRef.current;
+    if (token) {
+      headers[CART_SESSION_HEADER] = token;
+    } else {
+      params.set("anonymousId", anonymousId);
+    }
+    if (cartRef.current?.id) {
+      params.set("cartId", cartRef.current.id);
+    }
+    if (catalogLocale) {
+      params.set("catalogLocale", catalogLocale);
+    }
+    setIsMutating(true);
+    setError(null);
+    try {
+      const response = await fetch(
+        `${apiBaseUrl}/cart/payment-methods?${params.toString()}`,
+        token ? { headers } : void 0
+      );
+      const body = await parseCartApi(response);
+      return body.paymentMethods ?? [];
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Payment methods request failed");
+      return null;
+    } finally {
+      setIsMutating(false);
+    }
+  }, [anonymousId, apiBaseUrl, catalogLocale, enabled]);
+  const authorizePayment = useCallback3(
+    async (method) => {
+      if (!enabled || !anonymousId) {
+        return null;
+      }
+      const run = async () => {
+        orderNumberRef.current ??= `cat-${createAnonymousId()}`;
+        setIsMutating(true);
+        setError(null);
+        try {
+          const response = await fetch(`${apiBaseUrl}/cart/payment`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              anonymousId,
+              sessionToken: sessionTokenRef.current ?? void 0,
+              cartId: cartRef.current?.id,
+              catalogLocale,
+              method,
+              orderNumber: orderNumberRef.current
+            })
+          });
+          const body = await parseCartApi(response);
+          if (body.cart) {
+            applyCart(body.cart);
+          }
+          if (!body.payment) {
+            throw new CartRequestError("Payment response is missing", response.status);
+          }
+          return body.payment;
+        } catch (err) {
+          setError(err instanceof Error ? err.message : "Payment failed");
+          return null;
+        } finally {
+          setIsMutating(false);
+        }
+      };
+      const pending = mutationChainRef.current.then(run, run);
+      mutationChainRef.current = pending.then(
+        () => void 0,
+        () => void 0
+      );
+      return pending;
+    },
+    [anonymousId, apiBaseUrl, applyCart, catalogLocale, enabled]
+  );
+  const getOrder = useCallback3(
+    async (orderNumber) => {
+      if (!enabled || !anonymousId || !orderNumber.trim()) {
+        return null;
+      }
+      const params = new URLSearchParams();
+      const headers = {};
+      const token = sessionTokenRef.current;
+      if (token) {
+        headers[CART_SESSION_HEADER] = token;
+      }
+      params.set("anonymousId", anonymousId);
+      params.set("orderNumber", orderNumber.trim());
+      if (catalogLocale) {
+        params.set("catalogLocale", catalogLocale);
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(`${apiBaseUrl}/orders?${params.toString()}`, {
+          headers
+        });
+        const body = await parseCartApi(response);
+        return body.order ?? null;
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Order request failed");
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [anonymousId, apiBaseUrl, catalogLocale, enabled]
+  );
+  const listOrders = useCallback3(async () => {
+    if (!enabled || !anonymousId) {
+      return [];
+    }
+    const params = new URLSearchParams();
+    const headers = {};
+    const token = sessionTokenRef.current;
+    if (token) {
+      headers[CART_SESSION_HEADER] = token;
+    }
+    params.set("anonymousId", anonymousId);
+    if (catalogLocale) {
+      params.set("catalogLocale", catalogLocale);
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await fetch(`${apiBaseUrl}/orders?${params.toString()}`, {
+        headers
+      });
+      const body = await parseCartApi(response);
+      return body.orders ?? [];
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Order request failed");
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [anonymousId, apiBaseUrl, catalogLocale, enabled]);
+  const placeOrder = useCallback3(async () => {
+    if (!enabled || !anonymousId) {
+      return null;
+    }
+    const run = async () => {
+      if (!cartRef.current) {
+        return null;
+      }
+      orderNumberRef.current ??= `cat-${createAnonymousId()}`;
+      setIsMutating(true);
+      setError(null);
+      try {
+        const response = await fetch(`${apiBaseUrl}/cart/order`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            anonymousId,
+            sessionToken: sessionTokenRef.current ?? void 0,
+            cartId: cartRef.current.id,
+            catalogLocale,
+            orderNumber: orderNumberRef.current
+          })
+        });
+        const body = await parseCartApi(response);
+        if (!body.order) {
+          throw new CartRequestError("Order response is missing", response.status);
+        }
+        orderNumberRef.current = null;
+        applyCart(null);
+        return body.order;
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Checkout failed");
+        return null;
+      } finally {
+        setIsMutating(false);
+      }
+    };
+    const pending = mutationChainRef.current.then(run, run);
+    mutationChainRef.current = pending.then(
+      () => void 0,
+      () => void 0
+    );
+    return pending;
+  }, [anonymousId, apiBaseUrl, applyCart, catalogLocale, enabled]);
+  const login = useCallback3(
+    async (input) => {
+      if (!enabled) {
+        return null;
+      }
+      setIsLoggingIn(true);
+      setError(null);
+      try {
+        const response = await fetch(`${apiBaseUrl}/cart/login`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            email: input.email,
+            password: input.password,
+            anonymousId,
+            catalogLocale,
+            cartId: cartRef.current?.id
+          })
+        });
+        const body = await parseCartApi(response);
+        if (!body.sessionToken || !body.customer) {
+          throw new CartRequestError("Sign in failed", response.status);
+        }
+        persistSession(body.sessionToken, body.customer);
+        applyCart(body.cart ?? null);
+        return body.cart ?? null;
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Sign in failed");
+        return null;
+      } finally {
+        setIsLoggingIn(false);
+      }
+    },
+    [anonymousId, apiBaseUrl, applyCart, catalogLocale, enabled, persistSession]
+  );
+  const logout = useCallback3(async () => {
+    try {
+      await fetch(`${apiBaseUrl}/cart/logout`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+      });
+    } catch {
+    }
+    clearSession();
+    applyCart(null);
+    setAnonymousId(rotateAnonymousId());
+  }, [apiBaseUrl, applyCart, clearSession]);
+  const openCart = useCallback3(() => {
+    setIsCartOpen(true);
+    void refresh();
+  }, [refresh]);
+  const closeCart = useCallback3(() => setIsCartOpen(false), []);
+  const toggleCart = useCallback3(() => {
+    setIsCartOpen((open) => {
+      if (!open) {
+        void refresh();
+      }
+      return !open;
+    });
+  }, [refresh]);
+  return {
+    cart,
+    anonymousId,
+    customer,
+    isAuthenticated: Boolean(customer && sessionToken),
+    isLoading,
+    isMutating,
+    isLoggingIn,
+    error,
+    isCartOpen,
+    openCart,
+    closeCart,
+    toggleCart,
+    addToCart,
+    addItems,
+    removeFromCart,
+    updateQuantity,
+    setAddresses,
+    getShippingMethods,
+    setShippingMethod,
+    getPaymentMethods,
+    authorizePayment,
+    getOrder,
+    listOrders,
+    placeOrder,
+    login,
+    logout,
+    refresh
+  };
+}
+
+// src/hooks/useRecordingDuration.ts
+import { useEffect as useEffect4, useState as useState4 } from "react";
+function formatRecordingDuration(seconds) {
+  const mins = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function useRecordingDuration(isRecording) {
+  const [duration, setDuration] = useState4(0);
+  useEffect4(() => {
+    if (!isRecording) {
+      setDuration(0);
+      return;
+    }
+    const interval = setInterval(() => {
+      setDuration((current) => current + 1);
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [isRecording]);
+  return duration;
+}
+
+// src/hooks/useVoiceSearch.ts
+import { useCallback as useCallback4, useRef as useRef4, useState as useState5 } from "react";
+function playAudioSummary(base64) {
+  const audio = new Audio(`data:audio/mpeg;base64,${base64}`);
+  void audio.play();
+}
+async function fetchTtsSummary(baseUrl, text) {
+  const response = await fetch(`${baseUrl}/tts`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  if (!response.ok) {
+    throw new Error("TTS failed");
+  }
+  const blob = await response.blob();
+  const buffer = await blob.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function useVoiceSearch(options) {
+  const {
+    apiBaseUrl,
+    queryLocale,
+    catalogLocale,
+    locale,
+    onResults,
+    onTranscript,
+    enableTts = true,
+    enableMissions = false
+  } = options;
+  const [isRecording, setIsRecording] = useState5(false);
+  const [isProcessing, setIsProcessing] = useState5(false);
+  const [isLoadingTts, setIsLoadingTts] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [audioSummary, setAudioSummary] = useState5(null);
+  const mediaRecorderRef = useRef4(null);
+  const chunksRef = useRef4([]);
+  const baseUrl = apiBaseUrl.replace(/\/$/, "");
+  const clearAudioSummary = useCallback4(() => {
+    setAudioSummary(null);
+  }, []);
+  const replayAudioSummary = useCallback4(() => {
+    if (audioSummary) {
+      playAudioSummary(audioSummary);
+    }
+  }, [audioSummary]);
+  const stopRecording = useCallback4(() => {
+    if (mediaRecorderRef.current?.state === "recording") {
+      mediaRecorderRef.current.stop();
+    }
+    setIsRecording(false);
+  }, []);
+  const startRecording = useCallback4(async () => {
+    setError(null);
+    setAudioSummary(null);
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const mediaRecorder = new MediaRecorder(stream);
+      mediaRecorderRef.current = mediaRecorder;
+      chunksRef.current = [];
+      mediaRecorder.ondataavailable = (event) => {
+        if (event.data.size > 0) {
+          chunksRef.current.push(event.data);
+        }
+      };
+      mediaRecorder.onstop = async () => {
+        stream.getTracks().forEach((track) => track.stop());
+        const blob = new Blob(chunksRef.current, { type: "audio/webm" });
+        setIsProcessing(true);
+        try {
+          const formData = new FormData();
+          formData.append("audio", blob, "recording.webm");
+          appendLocaleFields(formData, { queryLocale, catalogLocale, locale });
+          formData.append("enableTts", String(enableTts));
+          if (enableMissions) {
+            formData.append("enableMissions", "true");
+          }
+          const response = await fetch(`${baseUrl}/search/voice`, {
+            method: "POST",
+            body: formData
+          });
+          if (!response.ok) {
+            const data2 = await response.json();
+            throw new Error(data2.error ?? "Voice search failed");
+          }
+          const data = await response.json();
+          onTranscript?.(data.transcript);
+          onResults?.(data.products, data.meta, { mission: data.mission });
+          if (data.audioSummary) {
+            setAudioSummary(data.audioSummary);
+            playAudioSummary(data.audioSummary);
+          } else if (enableTts && data.ttsText && data.ttsPending) {
+            setIsLoadingTts(true);
+            try {
+              const summary = await fetchTtsSummary(baseUrl, data.ttsText);
+              setAudioSummary(summary);
+              playAudioSummary(summary);
+            } catch {
+              setAudioSummary(null);
+            } finally {
+              setIsLoadingTts(false);
+            }
+          } else {
+            setAudioSummary(null);
+          }
+        } catch (err) {
+          setError(err instanceof Error ? err.message : "Voice search failed");
+          setAudioSummary(null);
+        } finally {
+          setIsProcessing(false);
+        }
+      };
+      mediaRecorder.start();
+      setIsRecording(true);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Microphone access denied");
+    }
+  }, [baseUrl, catalogLocale, enableMissions, enableTts, locale, onResults, onTranscript, queryLocale]);
+  const toggleRecording = useCallback4(async () => {
+    if (isRecording) {
+      stopRecording();
+    } else {
+      await startRecording();
+    }
+  }, [isRecording, startRecording, stopRecording]);
+  const clearError = useCallback4(() => {
+    setError(null);
+  }, []);
+  return {
+    isRecording,
+    isProcessing,
+    isLoadingTts,
+    error,
+    clearError,
+    audioSummary,
+    clearAudioSummary,
+    replayAudioSummary,
+    toggleRecording,
+    stopRecording
+  };
+}
+
+// src/icons.ts
+var ICON_STROKE = 1.25;
+
+// src/components/CameraCaptureOverlay.tsx
+import { useEffect as useEffect5, useRef as useRef5 } from "react";
+import { Camera, X } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function CameraCaptureOverlay({
+  stream,
+  error,
+  messages,
+  onCapture,
+  onClose,
+  onDismissError
+}) {
+  const videoRef = useRef5(null);
+  useEffect5(() => {
+    function onKeyDown(event) {
+      if (event.key === "Escape") {
+        if (error) {
+          onDismissError();
+        } else {
+          onClose();
+        }
+      }
+    }
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [error, onClose, onDismissError]);
+  useEffect5(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    video.srcObject = stream;
+    if (stream) {
+      const playPromise = video.play();
+      if (playPromise) {
+        void playPromise.catch(() => {
+        });
+      }
+    }
+    return () => {
+      video.srcObject = null;
+    };
+  }, [stream]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "cat-camera-overlay",
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": messages.cameraCapture,
+      children: /* @__PURE__ */ jsx("div", { className: "cat-camera-overlay__panel", children: error ? /* @__PURE__ */ jsxs("div", { className: "cat-camera-overlay__error", role: "alert", children: [
+        /* @__PURE__ */ jsx("p", { children: error }),
+        /* @__PURE__ */ jsx("button", { type: "button", className: "cat-camera-overlay__btn", onClick: onDismissError, children: messages.dismiss })
+      ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          "video",
+          {
+            ref: videoRef,
+            className: "cat-camera-preview",
+            autoPlay: true,
+            playsInline: true,
+            muted: true,
+            "aria-label": messages.cameraPreview
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "cat-camera-actions", children: [
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: "cat-camera-overlay__btn cat-camera-overlay__btn--secondary",
+              onClick: onClose,
+              "aria-label": messages.cancel,
+              children: [
+                /* @__PURE__ */ jsx(X, { size: 16, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+                messages.cancel
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: "cat-camera-overlay__btn cat-camera-overlay__btn--primary",
+              onClick: () => {
+                if (videoRef.current) onCapture(videoRef.current);
+              },
+              "aria-label": messages.capturePhoto,
+              children: [
+                /* @__PURE__ */ jsx(Camera, { size: 16, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+                messages.capturePhoto
+              ]
+            }
+          )
+        ] })
+      ] }) })
+    }
+  );
+}
+
+// src/components/CartPanel.tsx
+import { useState as useState6 } from "react";
+import {
+  ArrowRight,
+  ChevronDown,
+  Minus,
+  Package,
+  Plus,
+  ShoppingBag,
+  Trash2,
+  UserRound,
+  X as X2
+} from "lucide-react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function displayCartError(error, messages) {
+  if (!error) {
+    return null;
+  }
+  if (error === "Invalid credentials") {
+    return messages.invalidCredentials;
+  }
+  if (error === "Sign in failed" || error === "Login failed") {
+    return messages.signInFailed;
+  }
+  return error;
+}
+function formatLineTotal(price, quantity, locale) {
+  if (!price) {
+    return null;
+  }
+  return new Intl.NumberFormat(locale || void 0, {
+    style: "currency",
+    currency: price.currency
+  }).format(price.amount * quantity);
+}
+function CartPanel({
+  cart,
+  customer,
+  isLoading,
+  isLoggingIn,
+  error,
+  messages,
+  catalogLocale,
+  onClose,
+  onRemove,
+  onQuantityChange,
+  onLogin,
+  onLogout,
+  onCheckout
+}) {
+  const isEmpty = !cart || cart.lineItems.length === 0;
+  const [email, setEmail] = useState6("");
+  const [password, setPassword] = useState6("");
+  const [isAuthExpanded, setIsAuthExpanded] = useState6(false);
+  const visibleError = displayCartError(error, messages);
+  function handleLoginSubmit(event) {
+    event.preventDefault();
+    onLogin({ email, password });
+    setPassword("");
+  }
+  const authBlock = /* @__PURE__ */ jsx2("div", { className: "cat-cart-panel__auth", children: customer ? /* @__PURE__ */ jsxs2("div", { className: "cat-cart-panel__signed-in", children: [
+    /* @__PURE__ */ jsxs2("span", { children: [
+      messages.signedInAs,
+      " ",
+      customer.email
+    ] }),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        className: "cat-cart-panel__sign-out",
+        onClick: onLogout,
+        children: messages.signOut
+      }
+    )
+  ] }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        type: "button",
+        className: "cat-cart-panel__auth-toggle",
+        disabled: isLoggingIn,
+        "aria-expanded": isAuthExpanded,
+        onClick: () => setIsAuthExpanded((expanded) => !expanded),
+        children: [
+          /* @__PURE__ */ jsxs2("span", { className: "cat-cart-panel__auth-toggle-copy", children: [
+            /* @__PURE__ */ jsx2("span", { className: "cat-cart-panel__auth-icon", "aria-hidden": "true", children: /* @__PURE__ */ jsx2(UserRound, { size: 14, strokeWidth: ICON_STROKE }) }),
+            messages.signInToSyncCart
+          ] }),
+          /* @__PURE__ */ jsx2(
+            ChevronDown,
+            {
+              className: isAuthExpanded ? "cat-cart-panel__auth-chevron--open" : "",
+              size: 15,
+              strokeWidth: ICON_STROKE,
+              "aria-hidden": "true"
+            }
+          )
+        ]
+      }
+    ),
+    isAuthExpanded ? /* @__PURE__ */ jsxs2("form", { className: "cat-cart-panel__auth-form", onSubmit: handleLoginSubmit, children: [
+      /* @__PURE__ */ jsxs2("label", { className: "cat-cart-panel__field", children: [
+        /* @__PURE__ */ jsx2("span", { className: "cat-cart-panel__label", children: messages.email }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            className: "cat-cart-panel__input",
+            type: "email",
+            name: "email",
+            autoComplete: "email",
+            required: true,
+            disabled: isLoggingIn,
+            value: email,
+            onChange: (event) => setEmail(event.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2("label", { className: "cat-cart-panel__field", children: [
+        /* @__PURE__ */ jsx2("span", { className: "cat-cart-panel__label", children: messages.password }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            className: "cat-cart-panel__input",
+            type: "password",
+            name: "password",
+            autoComplete: "current-password",
+            required: true,
+            disabled: isLoggingIn,
+            value: password,
+            onChange: (event) => setPassword(event.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "submit",
+          className: "cat-cart-panel__submit",
+          disabled: isLoggingIn,
+          children: messages.signIn
+        }
+      )
+    ] }) : null
+  ] }) });
+  return /* @__PURE__ */ jsxs2(
+    "section",
+    {
+      className: `cat-cart-panel${isEmpty ? "" : " cat-cart-panel--with-items"}`,
+      "aria-label": messages.cartAriaLabel,
+      children: [
+        /* @__PURE__ */ jsxs2("header", { className: "cat-cart-panel__header", children: [
+          /* @__PURE__ */ jsx2("h2", { className: "cat-cart-panel__title", children: messages.cart }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              className: "cat-icon-btn",
+              onClick: onClose,
+              "aria-label": messages.closeCart,
+              children: /* @__PURE__ */ jsx2(X2, { size: 16, strokeWidth: ICON_STROKE })
+            }
+          )
+        ] }),
+        visibleError && /* @__PURE__ */ jsx2("div", { className: "cat-status cat-status--error", role: "alert", children: visibleError }),
+        isEmpty ? /* @__PURE__ */ jsxs2("div", { className: "cat-cart-panel__empty", children: [
+          /* @__PURE__ */ jsx2(ShoppingBag, { size: 20, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx2("span", { children: messages.emptyCart })
+        ] }) : /* @__PURE__ */ jsx2("ul", { className: "cat-cart-panel__items", children: cart.lineItems.map((item) => /* @__PURE__ */ jsxs2("li", { className: "cat-cart-item", children: [
+          item.imageUrl ? /* @__PURE__ */ jsx2("img", { src: item.imageUrl, alt: "", className: "cat-cart-item__image" }) : /* @__PURE__ */ jsx2("div", { className: "cat-cart-item__image cat-cart-item__image--placeholder", children: /* @__PURE__ */ jsx2(Package, { size: 16, strokeWidth: ICON_STROKE, "aria-hidden": "true" }) }),
+          /* @__PURE__ */ jsxs2("div", { className: "cat-cart-item__info", children: [
+            /* @__PURE__ */ jsx2("div", { className: "cat-cart-item__name", children: item.name }),
+            item.price ? /* @__PURE__ */ jsxs2("div", { className: "cat-cart-item__price", children: [
+              /* @__PURE__ */ jsxs2("span", { children: [
+                item.price.formatted,
+                " ",
+                messages.each
+              ] }),
+              /* @__PURE__ */ jsx2("strong", { children: item.totalPrice?.formatted ?? formatLineTotal(item.price, item.quantity, catalogLocale) })
+            ] }) : null,
+            /* @__PURE__ */ jsxs2("div", { className: "cat-cart-item__qty", children: [
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  type: "button",
+                  className: "cat-cart-item__qty-btn",
+                  "aria-label": messages.decreaseQuantity,
+                  disabled: isLoading || item.quantity <= 1,
+                  onClick: () => onQuantityChange(item.id, item.quantity - 1),
+                  children: /* @__PURE__ */ jsx2(Minus, { size: 12, strokeWidth: ICON_STROKE })
+                }
+              ),
+              /* @__PURE__ */ jsx2("span", { className: "cat-cart-item__qty-value", children: item.quantity }),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  type: "button",
+                  className: "cat-cart-item__qty-btn",
+                  "aria-label": messages.increaseQuantity,
+                  disabled: isLoading,
+                  onClick: () => onQuantityChange(item.id, item.quantity + 1),
+                  children: /* @__PURE__ */ jsx2(Plus, { size: 12, strokeWidth: ICON_STROKE })
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              className: "cat-icon-btn",
+              "aria-label": messages.removeItem,
+              disabled: isLoading,
+              onClick: () => onRemove(item.id),
+              children: /* @__PURE__ */ jsx2(Trash2, { size: 14, strokeWidth: ICON_STROKE })
+            }
+          )
+        ] }, item.id)) }),
+        authBlock,
+        !isEmpty && /* @__PURE__ */ jsxs2("footer", { className: "cat-cart-panel__footer", children: [
+          /* @__PURE__ */ jsxs2("div", { className: "cat-cart-panel__total", children: [
+            /* @__PURE__ */ jsx2("span", { children: messages.total }),
+            /* @__PURE__ */ jsx2("strong", { children: cart.totalPrice.formatted })
+          ] }),
+          onCheckout ? /* @__PURE__ */ jsxs2(
+            "button",
+            {
+              type: "button",
+              className: "cat-checkout-cta",
+              disabled: isLoading,
+              onClick: () => onCheckout(cart),
+              children: [
+                /* @__PURE__ */ jsx2("span", { children: messages.checkout }),
+                /* @__PURE__ */ jsx2("span", { className: "cat-checkout-cta__icon", "aria-hidden": "true", children: /* @__PURE__ */ jsx2(ArrowRight, { size: 15, strokeWidth: ICON_STROKE }) })
+              ]
+            }
+          ) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/MissionResults.tsx
+import { useEffect as useEffect6, useId, useMemo as useMemo2, useRef as useRef6, useState as useState7 } from "react";
+import { Check, Package as Package2, SearchX, ShoppingCart } from "lucide-react";
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatMissionAddAll(template, count) {
+  const withPlural = count === 1 ? template.replaceAll("top picks", "top pick") : template;
+  if (withPlural.includes("{count}")) {
+    return withPlural.replaceAll("{count}", String(count));
+  }
+  return `${withPlural} (${count})`;
+}
+function toCartItem(product, quantity) {
+  return product.sku ? { sku: product.sku, quantity } : { productId: product.id, variantId: product.variantId, quantity };
+}
+function lineItemKey(item) {
+  if (item.sku) {
+    return `sku:${item.sku}`;
+  }
+  return `id:${item.productId ?? ""}:${item.variantId ?? ""}`;
+}
+function starterBundleItems(mission) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const group of mission.intents) {
+    if (group.failed) {
+      continue;
+    }
+    const product = group.products[0];
+    if (!product || !product.sku && !product.id) {
+      continue;
+    }
+    const item = toCartItem(product, 1);
+    const key = lineItemKey(item);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    items.push(item);
+  }
+  return items;
+}
+function ProductCardBody({ product }) {
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+    product.imageUrl ? /* @__PURE__ */ jsx3("img", { src: product.imageUrl, alt: "", className: "cat-result-image", loading: "lazy" }) : /* @__PURE__ */ jsx3("div", { className: "cat-result-image cat-result-image--placeholder", children: /* @__PURE__ */ jsx3(Package2, { size: 20, strokeWidth: ICON_STROKE, color: "var(--cat-text-muted)" }) }),
+    /* @__PURE__ */ jsxs3("div", { className: "cat-result-info", children: [
+      /* @__PURE__ */ jsx3("div", { className: "cat-result-name", children: product.name }),
+      product.price ? /* @__PURE__ */ jsx3("div", { className: "cat-result-price", children: product.price.formatted }) : null
+    ] })
+  ] });
+}
+function MissionResults({
+  mission,
+  messages,
+  enableCart,
+  isMutating,
+  addedProductIds,
+  onProductSelect,
+  onAddItem,
+  onAddAll
+}) {
+  const titleId = useId();
+  const [justAddedAll, setJustAddedAll] = useState7(false);
+  const addedAllTimeoutRef = useRef6(null);
+  const bundleItems = useMemo2(() => starterBundleItems(mission), [mission]);
+  const totalQuantity = bundleItems.reduce((sum, item) => sum + (item.quantity ?? 1), 0);
+  useEffect6(() => {
+    setJustAddedAll(false);
+  }, [mission]);
+  useEffect6(() => {
+    return () => {
+      if (addedAllTimeoutRef.current !== null) {
+        window.clearTimeout(addedAllTimeoutRef.current);
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs3("div", { className: "cat-mission", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "cat-mission__header", children: [
+      /* @__PURE__ */ jsx3("h2", { id: titleId, className: "cat-mission__title", children: messages.missionTitle }),
+      mission.interpretation ? /* @__PURE__ */ jsx3("p", { className: "cat-mission__interpretation", children: mission.interpretation }) : null
+    ] }),
+    /* @__PURE__ */ jsx3("div", { className: "cat-mission__lanes", role: "list", "aria-labelledby": titleId, children: mission.intents.map((group) => /* @__PURE__ */ jsxs3("section", { className: "cat-mission-group", role: "listitem", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "cat-mission-group__header", children: [
+        /* @__PURE__ */ jsx3("h3", { className: "cat-mission-group__label", children: group.intent.label }),
+        group.intent.quantity > 1 ? /* @__PURE__ */ jsxs3("span", { className: "cat-mission-group__qty", children: [
+          messages.missionQuantity,
+          " ",
+          group.intent.quantity
+        ] }) : null
+      ] }),
+      group.failed ? /* @__PURE__ */ jsxs3("div", { className: "cat-status cat-status--empty", role: "status", children: [
+        /* @__PURE__ */ jsx3(SearchX, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx3("div", { className: "cat-status__content", children: /* @__PURE__ */ jsx3("div", { className: "cat-status__title", children: messages.missionIntentFailed }) })
+      ] }) : group.products.length === 0 ? /* @__PURE__ */ jsxs3("div", { className: "cat-status cat-status--empty", role: "status", children: [
+        /* @__PURE__ */ jsx3(SearchX, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx3("div", { className: "cat-status__content", children: /* @__PURE__ */ jsx3("div", { className: "cat-status__title", children: messages.missionIntentEmpty }) })
+      ] }) : /* @__PURE__ */ jsx3("div", { className: "cat-mission-group__products", children: group.products.map((product, index) => {
+        const canAdd = Boolean(product.sku || product.id);
+        const justAdded = Boolean(addedProductIds?.[product.id]);
+        const body = /* @__PURE__ */ jsx3(ProductCardBody, { product });
+        return /* @__PURE__ */ jsx3(
+          "article",
+          {
+            className: `cat-result-card ${index === 0 ? "cat-result-card--primary" : "cat-result-card--compact"}`,
+            children: /* @__PURE__ */ jsxs3("div", { className: "cat-result-card__core", children: [
+              onProductSelect ? /* @__PURE__ */ jsx3(
+                "button",
+                {
+                  type: "button",
+                  className: "cat-result-card__select",
+                  onClick: () => onProductSelect(product),
+                  children: body
+                }
+              ) : /* @__PURE__ */ jsx3("div", { className: "cat-result-card__select", children: body }),
+              enableCart ? /* @__PURE__ */ jsx3(
+                "button",
+                {
+                  type: "button",
+                  className: `cat-icon-btn cat-result-card__add${justAdded ? " cat-result-card__add--added" : ""}`,
+                  "aria-label": justAdded ? messages.itemAdded : canAdd ? messages.addToCart : messages.unableToAddToCart,
+                  disabled: !canAdd || isMutating,
+                  onClick: () => onAddItem?.(product),
+                  children: justAdded ? /* @__PURE__ */ jsx3(Check, { size: 16, strokeWidth: ICON_STROKE }) : /* @__PURE__ */ jsx3(ShoppingCart, { size: 16, strokeWidth: ICON_STROKE })
+                }
+              ) : null
+            ] })
+          },
+          product.id
+        );
+      }) })
+    ] }, group.intent.id)) }),
+    enableCart ? /* @__PURE__ */ jsx3("div", { className: "cat-mission__footer", children: /* @__PURE__ */ jsx3(
+      "button",
+      {
+        type: "button",
+        className: `cat-checkout-cta cat-mission__add-all${justAddedAll ? " cat-mission__add-all--added" : ""}`,
+        disabled: isMutating || bundleItems.length === 0,
+        onClick: () => {
+          void onAddAll(bundleItems).then((result) => {
+            if (result) {
+              setJustAddedAll(true);
+              if (addedAllTimeoutRef.current !== null) {
+                window.clearTimeout(addedAllTimeoutRef.current);
+              }
+              addedAllTimeoutRef.current = window.setTimeout(() => {
+                setJustAddedAll(false);
+                addedAllTimeoutRef.current = null;
+              }, 1200);
+            }
+          });
+        },
+        children: justAddedAll ? messages.missionItemsAdded : formatMissionAddAll(messages.missionAddAll, totalQuantity)
+      }
+    ) }) : null
+  ] });
+}
+
+// src/components/SearchFacets.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function SearchFacets({
+  facets,
+  suggestedFacets,
+  filters,
+  messages,
+  onChange,
+  onNewSearch
+}) {
+  const suggestedNames = new Set(suggestedFacets.map((facet) => facet.name));
+  const visibleFacets = facets.filter((facet) => suggestedNames.size === 0 || suggestedNames.has(facet.id));
+  if (!visibleFacets.length) return null;
+  return /* @__PURE__ */ jsxs4("section", { className: "cat-facets", "aria-label": messages.filtersAriaLabel, children: [
+    /* @__PURE__ */ jsxs4("div", { className: "cat-facets__header", children: [
+      /* @__PURE__ */ jsx4("span", { children: messages.narrowResults }),
+      /* @__PURE__ */ jsxs4("div", { className: "cat-facets__actions", children: [
+        Object.keys(filters).length > 0 && /* @__PURE__ */ jsx4("button", { type: "button", className: "cat-facets__clear", onClick: () => onChange({}), children: messages.clearFilters }),
+        onNewSearch && /* @__PURE__ */ jsx4("button", { type: "button", className: "cat-facets__new", onClick: onNewSearch, children: messages.newSearch })
+      ] })
+    ] }),
+    visibleFacets.map((facet) => /* @__PURE__ */ jsxs4("div", { className: "cat-facet-group", role: "group", "aria-label": facet.label, children: [
+      /* @__PURE__ */ jsx4("span", { className: "cat-facet-group__label", children: facet.label }),
+      /* @__PURE__ */ jsx4("div", { className: "cat-facet-group__options", children: facet.buckets.map((bucket) => {
+        const selected = isFacetFilterSelected(filters, facet.id, bucket.key);
+        const swatch = isColorLikeFacetName(facet.id) ? hexColorSwatchValue(bucket.key) : void 0;
+        return /* @__PURE__ */ jsxs4(
+          "button",
+          {
+            type: "button",
+            className: `cat-facet-chip ${selected ? "cat-facet-chip--selected" : ""}`,
+            "aria-pressed": selected,
+            onClick: () => onChange(toggleFacetFilter(filters, facet.id, bucket.key)),
+            children: [
+              swatch ? /* @__PURE__ */ jsx4(
+                "span",
+                {
+                  className: "cat-facet-chip__swatch",
+                  style: { backgroundColor: swatch },
+                  "aria-hidden": "true"
+                }
+              ) : null,
+              bucket.label,
+              " ",
+              /* @__PURE__ */ jsx4("span", { className: "cat-facet-chip__count", "aria-hidden": "true", children: bucket.count })
+            ]
+          },
+          bucket.key
+        );
+      }) })
+    ] }, facet.id))
+  ] });
+}
+
+// src/components/VoiceStatusBanner.tsx
+import { X as X3 } from "lucide-react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function VoiceWaveform() {
+  return /* @__PURE__ */ jsxs5("div", { className: "cat-voice-waveform", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx5("span", {}),
+    /* @__PURE__ */ jsx5("span", {}),
+    /* @__PURE__ */ jsx5("span", {}),
+    /* @__PURE__ */ jsx5("span", {}),
+    /* @__PURE__ */ jsx5("span", {})
+  ] });
+}
+function ProcessingSpinner() {
+  return /* @__PURE__ */ jsx5("span", { className: "cat-voice-spinner", "aria-hidden": "true" });
+}
+function VoiceStatusBanner({
+  isRecording,
+  isProcessing,
+  isLoadingTts,
+  error,
+  durationSeconds,
+  messages,
+  onDismissError
+}) {
+  const isError = Boolean(error);
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: `cat-voice-banner ${isError ? "cat-voice-banner--error" : ""}`,
+      role: "status",
+      "aria-live": "polite",
+      children: [
+        isError && /* @__PURE__ */ jsxs5("div", { className: "cat-voice-banner__content", children: [
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__label", children: error }),
+          onDismissError && /* @__PURE__ */ jsx5(
+            "button",
+            {
+              type: "button",
+              className: "cat-voice-banner__dismiss",
+              onClick: onDismissError,
+              "aria-label": messages.dismiss,
+              children: /* @__PURE__ */ jsx5(X3, { size: 14, strokeWidth: ICON_STROKE, "aria-hidden": "true" })
+            }
+          )
+        ] }),
+        !isError && isRecording && /* @__PURE__ */ jsxs5("div", { className: "cat-voice-banner__content", children: [
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-dot", "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__label", children: messages.listening }),
+          /* @__PURE__ */ jsx5(VoiceWaveform, {}),
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__timer", children: formatRecordingDuration(durationSeconds) }),
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__hint", children: messages.tapMicToStop })
+        ] }),
+        !isError && !isRecording && isProcessing && /* @__PURE__ */ jsxs5("div", { className: "cat-voice-banner__content", children: [
+          /* @__PURE__ */ jsx5(ProcessingSpinner, {}),
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__label", children: messages.understandingQuery })
+        ] }),
+        !isError && !isRecording && !isProcessing && isLoadingTts && /* @__PURE__ */ jsxs5("div", { className: "cat-voice-banner__content", children: [
+          /* @__PURE__ */ jsx5(ProcessingSpinner, {}),
+          /* @__PURE__ */ jsx5("span", { className: "cat-voice-banner__label", children: messages.preparingAudioSummary })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/CommerceAISearch.tsx
+import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function CommerceAISearch({
+  apiBaseUrl,
+  theme = "auto",
+  catalogLocale,
+  queryLocale,
+  locale,
+  placeholder,
+  messages: messageOverrides,
+  enableAutocomplete = false,
+  enableFacets = false,
+  persistSession = true,
+  enableVoice = true,
+  enableImageSearch = true,
+  enableCameraSearch = true,
+  cameraFacingMode = "environment",
+  enableTts = true,
+  enableCart = false,
+  enableMissions = false,
+  currency,
+  country,
+  className,
+  onProductSelect,
+  onCartChange,
+  onCheckout
+}) {
+  const messages = useMemo3(
+    () => resolveCommerceAISearchMessages({
+      ...messageOverrides,
+      ...placeholder ? { placeholder } : {}
+    }),
+    [messageOverrides, placeholder]
+  );
+  const fileInputRef = useRef7(null);
+  const cameraInputRef = useRef7(null);
+  const [isDragging, setIsDragging] = useState8(false);
+  const [lastSearchMode, setLastSearchMode] = useState8(null);
+  const [activeSuggestionIndex, setActiveSuggestionIndex] = useState8(-1);
+  const [suggestionsDismissed, setSuggestionsDismissed] = useState8(false);
+  const camera = useCameraCapture({ facingMode: cameraFacingMode });
+  const {
+    query,
+    setQuery,
+    suggestions,
+    isLoadingSuggestions,
+    suggestionsError,
+    suggestionsReady,
+    selectSuggestion,
+    results,
+    mission,
+    isLoading,
+    hasSearched,
+    setHasSearched,
+    error,
+    meta,
+    search,
+    searchByImage,
+    setError,
+    setIsLoading,
+    facets = [],
+    suggestedFacets = [],
+    hasFacetSession = false,
+    refineFilters = async () => void 0,
+    refine = async () => void 0,
+    startNewSearch = async () => void 0,
+    applySearchResult = () => void 0
+  } = useCommerceAISearch({
+    apiBaseUrl,
+    catalogLocale,
+    queryLocale,
+    locale,
+    enableAutocomplete,
+    enableFacets,
+    persistSession,
+    enableMissions
+  });
+  const voice = useVoiceSearch({
+    apiBaseUrl,
+    catalogLocale,
+    queryLocale,
+    locale,
+    enableTts,
+    enableMissions,
+    onResults: (products, resultMeta, extras) => {
+      setLastSearchMode("voice");
+      applySearchResult({
+        products,
+        meta: resultMeta,
+        mission: extras?.mission
+      });
+      setError(null);
+      setIsLoading(false);
+      setHasSearched(true);
+    },
+    onTranscript: (transcript) => setQuery(transcript, { search: false })
+  });
+  const recordingDuration = useRecordingDuration(voice.isRecording);
+  const showVoiceBanner = enableVoice && (voice.isRecording || voice.isProcessing || voice.isLoadingTts || Boolean(voice.error));
+  const cart = useCart({
+    apiBaseUrl,
+    currency,
+    country,
+    catalogLocale,
+    enabled: enableCart,
+    onCartChange
+  });
+  const cartQuantity = cart.cart?.totalQuantity ?? 0;
+  const cartBadgeLabel = cartQuantity > 99 ? "99+" : String(cartQuantity);
+  const [addedProductIds, setAddedProductIds] = useState8({});
+  const handleAddToCart = useCallback5(
+    async (product) => {
+      if (!product.sku && !product.id) {
+        return;
+      }
+      const next = await cart.addToCart(
+        product.sku ? { sku: product.sku } : { productId: product.id, variantId: product.variantId }
+      );
+      if (!next) {
+        return;
+      }
+      setAddedProductIds((current) => ({ ...current, [product.id]: true }));
+      window.setTimeout(() => {
+        setAddedProductIds((current) => {
+          const nextAdded = { ...current };
+          delete nextAdded[product.id];
+          return nextAdded;
+        });
+      }, 1200);
+    },
+    [cart.addToCart]
+  );
+  const displayResults = results;
+  const showMission = Boolean(mission);
+  const missionLaneCount = mission?.intents.length ?? 0;
+  const showEmptyResults = !isLoading && !error && hasSearched && displayResults.length === 0 && !showMission && query.trim().length > 0;
+  const showResults = query.trim().length > 0 && (isLoading || !!error || displayResults.length > 0 || showEmptyResults || showMission);
+  const showSuggestions = enableAutocomplete && !suggestionsDismissed && !showResults && query.trim().length >= 2 && (isLoadingSuggestions || suggestions.length > 0 || !!suggestionsError || suggestionsReady);
+  const handleSubmit = useCallback5(
+    (event) => {
+      event.preventDefault();
+      setLastSearchMode("text");
+      voice.clearAudioSummary();
+      setActiveSuggestionIndex(-1);
+      if (enableAutocomplete && activeSuggestionIndex >= 0 && suggestions[activeSuggestionIndex]) {
+        selectSuggestion(suggestions[activeSuggestionIndex]);
+        return;
+      }
+      if (enableFacets && hasFacetSession && !(enableMissions && looksLikeCompoundShoppingList(query))) {
+        void refine(query);
+      } else {
+        void search(query);
+      }
+    },
+    [
+      activeSuggestionIndex,
+      enableAutocomplete,
+      enableFacets,
+      enableMissions,
+      hasFacetSession,
+      query,
+      refine,
+      search,
+      selectSuggestion,
+      suggestions,
+      voice
+    ]
+  );
+  const handleQueryChange = useCallback5(
+    (value) => {
+      setActiveSuggestionIndex(-1);
+      setSuggestionsDismissed(false);
+      const trimmed = value.trim();
+      if (!trimmed) {
+        setLastSearchMode(null);
+        voice.clearAudioSummary();
+      } else if (trimmed.length >= 2) {
+        setLastSearchMode("text");
+        voice.clearAudioSummary();
+      }
+      setQuery(value);
+    },
+    [setQuery, voice]
+  );
+  const handleSuggestionSelect = useCallback5(
+    (suggestion) => {
+      setActiveSuggestionIndex(-1);
+      setLastSearchMode("text");
+      voice.clearAudioSummary();
+      selectSuggestion(suggestion);
+    },
+    [selectSuggestion, voice]
+  );
+  const handleInputKeyDown = useCallback5(
+    (event) => {
+      if (event.key === "Escape") {
+        setActiveSuggestionIndex(-1);
+        setSuggestionsDismissed(true);
+        return;
+      }
+      if (!showSuggestions || suggestions.length === 0) {
+        return;
+      }
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        setActiveSuggestionIndex((current) => current < suggestions.length - 1 ? current + 1 : 0);
+        return;
+      }
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        setActiveSuggestionIndex((current) => current > 0 ? current - 1 : suggestions.length - 1);
+        return;
+      }
+      if (event.key === "Enter" && activeSuggestionIndex >= 0) {
+        event.preventDefault();
+        const suggestion = suggestions[activeSuggestionIndex];
+        if (suggestion) {
+          handleSuggestionSelect(suggestion);
+        }
+      }
+    },
+    [activeSuggestionIndex, handleSuggestionSelect, showSuggestions, suggestions]
+  );
+  const handleImageSelect = useCallback5(
+    (file) => {
+      if (!file.type.startsWith("image/")) return;
+      setLastSearchMode("image");
+      voice.clearAudioSummary();
+      void searchByImage(file);
+    },
+    [searchByImage, voice]
+  );
+  const handleCameraCapture = useCallback5(
+    async (video) => {
+      try {
+        const file = await camera.capturePhoto(video);
+        handleImageSelect(file);
+      } catch (err) {
+        camera.close();
+        setError(err instanceof Error ? err.message : messages.couldNotCapturePhoto);
+      }
+    },
+    [camera, handleImageSelect, messages.couldNotCapturePhoto, setError]
+  );
+  const handleDrop = useCallback5(
+    (event) => {
+      event.preventDefault();
+      setIsDragging(false);
+      if (!enableImageSearch) {
+        return;
+      }
+      const file = event.dataTransfer.files[0];
+      if (file) handleImageSelect(file);
+    },
+    [enableImageSearch, handleImageSelect]
+  );
+  const showVoiceReplay = enableVoice && enableTts && lastSearchMode === "voice" && Boolean(voice.audioSummary);
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      className: [
+        "cat-root",
+        "cat-wrapper",
+        showMission && !isLoading && !error ? `cat-root--mission cat-root--mission-lanes-${Math.min(Math.max(missionLaneCount, 1), 5)}` : "",
+        className ?? ""
+      ].filter(Boolean).join(" "),
+      "data-theme": theme,
+      onDragOver: (e) => {
+        if (!enableImageSearch) {
+          return;
+        }
+        e.preventDefault();
+        setIsDragging(true);
+      },
+      onDragLeave: () => setIsDragging(false),
+      onDrop: handleDrop,
+      role: "search",
+      "aria-label": messages.productSearchAriaLabel,
+      children: [
+        isDragging && enableImageSearch && /* @__PURE__ */ jsx6("div", { className: "cat-drag-overlay", "aria-hidden": "true", children: messages.dropImageToSearch }),
+        /* @__PURE__ */ jsx6("div", { className: "cat-search-shell", children: /* @__PURE__ */ jsxs6(
+          "form",
+          {
+            className: `cat-search-bar ${voice.isRecording ? "cat-search-bar--voice-active" : ""}`,
+            onSubmit: handleSubmit,
+            children: [
+              /* @__PURE__ */ jsx6(Search, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true", color: "var(--cat-text-muted)" }),
+              /* @__PURE__ */ jsx6("div", { className: "cat-search-input-wrap", children: /* @__PURE__ */ jsx6(
+                "input",
+                {
+                  type: "search",
+                  className: "cat-search-input",
+                  value: query,
+                  onChange: (e) => handleQueryChange(e.target.value),
+                  onKeyDown: handleInputKeyDown,
+                  placeholder: messages.placeholder,
+                  "aria-label": messages.searchAriaLabel,
+                  "aria-haspopup": enableAutocomplete ? "listbox" : void 0,
+                  "aria-autocomplete": enableAutocomplete ? "list" : void 0,
+                  "aria-expanded": showSuggestions,
+                  "aria-controls": showSuggestions ? "cat-suggestions-listbox" : void 0,
+                  "aria-activedescendant": activeSuggestionIndex >= 0 ? `cat-suggestion-${activeSuggestionIndex}` : void 0,
+                  autoComplete: "off",
+                  role: enableAutocomplete ? "combobox" : void 0
+                }
+              ) }),
+              /* @__PURE__ */ jsxs6("div", { className: "cat-search-actions", children: [
+                enableVoice && /* @__PURE__ */ jsx6(
+                  "button",
+                  {
+                    type: "button",
+                    className: `cat-icon-btn ${voice.isRecording ? "cat-icon-btn--active" : ""}`,
+                    onClick: () => void voice.toggleRecording(),
+                    disabled: voice.isProcessing,
+                    "aria-label": voice.isRecording ? messages.stopRecording : messages.voiceSearch,
+                    "aria-pressed": voice.isRecording,
+                    children: voice.isRecording ? /* @__PURE__ */ jsx6(Square, { size: 16, strokeWidth: ICON_STROKE }) : /* @__PURE__ */ jsx6(Mic, { size: 16, strokeWidth: ICON_STROKE })
+                  }
+                ),
+                enableCameraSearch ? /* @__PURE__ */ jsxs6(Fragment4, { children: [
+                  /* @__PURE__ */ jsx6(
+                    "button",
+                    {
+                      type: "button",
+                      className: "cat-icon-btn",
+                      onClick: () => camera.open(cameraInputRef),
+                      disabled: isLoading,
+                      "aria-label": messages.searchByCamera,
+                      children: /* @__PURE__ */ jsx6(Camera2, { size: 16, strokeWidth: ICON_STROKE })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx6(
+                    "input",
+                    {
+                      ref: cameraInputRef,
+                      type: "file",
+                      accept: "image/*",
+                      capture: cameraFacingMode,
+                      className: "cat-hidden-input",
+                      onChange: (e) => {
+                        const file = e.target.files?.[0];
+                        e.target.value = "";
+                        if (file) handleImageSelect(file);
+                      }
+                    }
+                  )
+                ] }) : null,
+                enableImageSearch ? /* @__PURE__ */ jsxs6(Fragment4, { children: [
+                  /* @__PURE__ */ jsx6(
+                    "button",
+                    {
+                      type: "button",
+                      className: "cat-icon-btn",
+                      onClick: () => fileInputRef.current?.click(),
+                      disabled: isLoading,
+                      "aria-label": messages.searchByImage,
+                      children: /* @__PURE__ */ jsx6(ImageIcon, { size: 16, strokeWidth: ICON_STROKE })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx6(
+                    "input",
+                    {
+                      ref: fileInputRef,
+                      type: "file",
+                      accept: "image/*",
+                      className: "cat-hidden-input",
+                      onChange: (e) => {
+                        const file = e.target.files?.[0];
+                        if (file) handleImageSelect(file);
+                      }
+                    }
+                  )
+                ] }) : null,
+                showVoiceReplay && /* @__PURE__ */ jsx6(
+                  "button",
+                  {
+                    type: "button",
+                    className: "cat-icon-btn",
+                    onClick: () => voice.replayAudioSummary(),
+                    "aria-label": messages.replayVoiceSummary,
+                    children: /* @__PURE__ */ jsx6(Volume2, { size: 16, strokeWidth: ICON_STROKE })
+                  }
+                )
+              ] }),
+              enableCart && /* @__PURE__ */ jsxs6(
+                "button",
+                {
+                  type: "button",
+                  className: `cat-icon-btn cat-cart-toggle ${cart.isCartOpen ? "cat-cart-toggle--open" : ""}`,
+                  onClick: cart.toggleCart,
+                  "aria-label": cartQuantity > 0 ? `${messages.cartAriaLabel} (${cartBadgeLabel})` : messages.cartAriaLabel,
+                  "aria-expanded": cart.isCartOpen,
+                  "aria-pressed": cart.isCartOpen,
+                  children: [
+                    /* @__PURE__ */ jsx6(ShoppingCart2, { size: 16, strokeWidth: ICON_STROKE }),
+                    cartQuantity > 0 && /* @__PURE__ */ jsx6("span", { className: "cat-cart-badge", "aria-hidden": "true", children: cartBadgeLabel })
+                  ]
+                }
+              ),
+              showSuggestions && /* @__PURE__ */ jsxs6(
+                "div",
+                {
+                  id: "cat-suggestions-listbox",
+                  className: "cat-suggestions",
+                  role: "listbox",
+                  "aria-label": messages.suggestionsAriaLabel,
+                  children: [
+                    isLoadingSuggestions && suggestions.length === 0 && !suggestionsError && /* @__PURE__ */ jsx6("div", { className: "cat-suggestions__status", children: messages.loadingSuggestions }),
+                    suggestionsError && /* @__PURE__ */ jsx6("div", { className: "cat-suggestions__status cat-suggestions__status--error", role: "alert", children: suggestionsError }),
+                    !isLoadingSuggestions && !suggestionsError && suggestionsReady && suggestions.length === 0 && /* @__PURE__ */ jsx6("div", { className: "cat-suggestions__status", children: messages.noSuggestions }),
+                    suggestions.map((suggestion, index) => /* @__PURE__ */ jsx6(
+                      "button",
+                      {
+                        id: `cat-suggestion-${index}`,
+                        type: "button",
+                        className: `cat-suggestions__item ${index === activeSuggestionIndex ? "cat-suggestions__item--active" : ""}`,
+                        role: "option",
+                        "aria-selected": index === activeSuggestionIndex,
+                        onMouseDown: (event) => event.preventDefault(),
+                        onClick: () => handleSuggestionSelect(suggestion),
+                        children: suggestion
+                      },
+                      `${index}-${suggestion}`
+                    ))
+                  ]
+                }
+              )
+            ]
+          }
+        ) }),
+        showVoiceBanner && /* @__PURE__ */ jsx6(
+          VoiceStatusBanner,
+          {
+            isRecording: voice.isRecording,
+            isProcessing: voice.isProcessing,
+            isLoadingTts: voice.isLoadingTts,
+            error: voice.error,
+            durationSeconds: recordingDuration,
+            messages,
+            onDismissError: voice.clearError
+          }
+        ),
+        enableFacets && lastSearchMode === "text" && hasSearched && !showMission && /* @__PURE__ */ jsx6(
+          SearchFacets,
+          {
+            facets,
+            suggestedFacets,
+            filters: meta?.appliedFilters ?? {},
+            messages,
+            onChange: (filters) => void refineFilters(filters),
+            onNewSearch: () => void startNewSearch()
+          }
+        ),
+        enableCameraSearch && (camera.isOpen || camera.error) && /* @__PURE__ */ jsx6(
+          CameraCaptureOverlay,
+          {
+            stream: camera.stream,
+            error: camera.error,
+            messages,
+            onCapture: (video) => void handleCameraCapture(video),
+            onClose: camera.close,
+            onDismissError: camera.clearError
+          }
+        ),
+        showResults && isLoading && /* @__PURE__ */ jsx6("div", { className: "cat-status", children: messages.searching }),
+        showResults && error && /* @__PURE__ */ jsx6("div", { className: "cat-status cat-status--error", children: error }),
+        !isLoading && !error && showResults && showMission && mission ? /* @__PURE__ */ jsx6(
+          MissionResults,
+          {
+            mission,
+            messages,
+            enableCart,
+            isMutating: cart.isMutating,
+            addedProductIds,
+            onProductSelect,
+            onAddItem: (product) => void handleAddToCart(product),
+            onAddAll: (items) => cart.addItems(items)
+          }
+        ) : null,
+        showResults && !showMission && !isLoading && !error && /* @__PURE__ */ jsxs6(
+          "div",
+          {
+            className: "cat-results",
+            role: !isLoading && displayResults.length > 0 ? "list" : void 0,
+            "aria-label": !isLoading && displayResults.length > 0 ? messages.searchResultsAriaLabel : void 0,
+            children: [
+              !isLoading && displayResults.map((product, index) => {
+                const canAdd = Boolean(product.sku || product.id);
+                const justAdded = Boolean(addedProductIds[product.id]);
+                const productBody = /* @__PURE__ */ jsxs6(Fragment4, { children: [
+                  product.imageUrl ? /* @__PURE__ */ jsx6(
+                    "img",
+                    {
+                      src: product.imageUrl,
+                      alt: "",
+                      className: "cat-result-image",
+                      loading: "lazy"
+                    }
+                  ) : /* @__PURE__ */ jsx6("div", { className: "cat-result-image cat-result-image--placeholder", children: /* @__PURE__ */ jsx6(Package3, { size: 20, strokeWidth: ICON_STROKE, color: "var(--cat-text-muted)" }) }),
+                  /* @__PURE__ */ jsxs6("div", { className: "cat-result-info", children: [
+                    /* @__PURE__ */ jsx6("div", { className: "cat-result-name", children: product.name }),
+                    product.price && /* @__PURE__ */ jsx6("div", { className: "cat-result-price", children: product.price.formatted })
+                  ] })
+                ] });
+                return /* @__PURE__ */ jsx6(
+                  "article",
+                  {
+                    className: `cat-result-card${index === 0 ? " cat-result-card--featured" : ""}`,
+                    role: "listitem",
+                    children: /* @__PURE__ */ jsxs6("div", { className: "cat-result-card__core", children: [
+                      /* @__PURE__ */ jsx6(
+                        "button",
+                        {
+                          type: "button",
+                          className: "cat-result-card__select",
+                          onClick: () => onProductSelect?.(product),
+                          children: productBody
+                        }
+                      ),
+                      enableCart ? /* @__PURE__ */ jsx6(
+                        "button",
+                        {
+                          type: "button",
+                          className: `cat-icon-btn cat-result-card__add ${justAdded ? "cat-result-card__add--added" : ""}`,
+                          "aria-label": justAdded ? messages.itemAdded : canAdd ? messages.addToCart : messages.unableToAddToCart,
+                          disabled: !canAdd || cart.isMutating,
+                          onClick: () => handleAddToCart(product),
+                          children: justAdded ? /* @__PURE__ */ jsx6(Check2, { size: 16, strokeWidth: ICON_STROKE }) : /* @__PURE__ */ jsx6(ShoppingCart2, { size: 16, strokeWidth: ICON_STROKE })
+                        }
+                      ) : null
+                    ] })
+                  },
+                  product.id
+                );
+              }),
+              !isLoading && !error && displayResults.length === 0 && showEmptyResults && /* @__PURE__ */ jsxs6("div", { className: "cat-status cat-status--empty", role: "status", "aria-live": "polite", children: [
+                /* @__PURE__ */ jsx6(SearchX2, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+                /* @__PURE__ */ jsxs6("div", { className: "cat-status__content", children: [
+                  /* @__PURE__ */ jsx6("div", { className: "cat-status__title", children: messages.noProductsFound }),
+                  meta?.queryInterpretation && /* @__PURE__ */ jsxs6("div", { className: "cat-status__hint", children: [
+                    messages.searchedFor,
+                    " ",
+                    meta.queryInterpretation
+                  ] })
+                ] })
+              ] })
+            ]
+          }
+        ),
+        enableCart && cart.isCartOpen && /* @__PURE__ */ jsx6(
+          CartPanel,
+          {
+            cart: cart.cart,
+            customer: cart.customer,
+            isLoading: cart.isLoading || cart.isMutating,
+            isLoggingIn: cart.isLoggingIn,
+            error: cart.error,
+            messages,
+            catalogLocale,
+            onClose: cart.closeCart,
+            onRemove: (lineItemId) => void cart.removeFromCart(lineItemId),
+            onQuantityChange: (lineItemId, quantity) => void cart.updateQuantity(lineItemId, quantity),
+            onLogin: (input) => void cart.login(input),
+            onLogout: () => void cart.logout(),
+            onCheckout
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/CommerceAICheckout.tsx
+import {
+  useMemo as useMemo4,
+  useState as useState9,
+  useTransition
+} from "react";
+import { ArrowLeft, ArrowRight as ArrowRight2, Check as Check3, CreditCard, MapPin, Package as Package4 } from "lucide-react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var CHECKOUT_COUNTRY_CODES = [
+  "AT",
+  "BE",
+  "CH",
+  "CZ",
+  "DE",
+  "DK",
+  "ES",
+  "FI",
+  "FR",
+  "GB",
+  "IE",
+  "IT",
+  "NL",
+  "NO",
+  "PL",
+  "PT",
+  "SE",
+  "US"
+];
+function checkoutCountryCodes(selected) {
+  const codes = new Set(CHECKOUT_COUNTRY_CODES);
+  const normalized = selected.trim().toUpperCase();
+  if (normalized.length === 2) {
+    codes.add(normalized);
+  }
+  return [...codes].sort();
+}
+function countryLabel(code, locale = "en") {
+  try {
+    return new Intl.DisplayNames([locale, "en"], { type: "region" }).of(code) ?? code;
+  } catch {
+    try {
+      return new Intl.DisplayNames(["en"], { type: "region" }).of(code) ?? code;
+    } catch {
+      return code;
+    }
+  }
+}
+function createEmptyAddress(country) {
+  return {
+    firstName: "",
+    lastName: "",
+    streetName: "",
+    postalCode: "",
+    city: "",
+    country
+  };
+}
+function AddressFields({
+  address,
+  messages,
+  prefix,
+  locale = "en",
+  onChange
+}) {
+  function update(field, event) {
+    onChange({ ...address, [field]: event.target.value });
+  }
+  return /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__address-grid", children: [
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.firstName }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-firstName`,
+          autoComplete: "given-name",
+          required: true,
+          value: address.firstName,
+          onChange: (event) => update("firstName", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.lastName }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-lastName`,
+          autoComplete: "family-name",
+          required: true,
+          value: address.lastName,
+          onChange: (event) => update("lastName", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field cat-checkout__field--wide", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.streetName }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-streetName`,
+          autoComplete: "address-line1",
+          required: true,
+          value: address.streetName,
+          onChange: (event) => update("streetName", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field cat-checkout__field--wide", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.additionalAddress }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-additionalStreetInfo`,
+          autoComplete: "address-line2",
+          value: address.additionalStreetInfo ?? "",
+          onChange: (event) => update("additionalStreetInfo", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.postalCode }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-postalCode`,
+          autoComplete: "postal-code",
+          required: true,
+          value: address.postalCode,
+          onChange: (event) => update("postalCode", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.city }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-city`,
+          autoComplete: "address-level2",
+          required: true,
+          value: address.city,
+          onChange: (event) => update("city", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.region }),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          name: `${prefix}-region`,
+          autoComplete: "address-level1",
+          value: address.region ?? "",
+          onChange: (event) => update("region", event)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__field", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.country }),
+      /* @__PURE__ */ jsx7(
+        "select",
+        {
+          name: `${prefix}-country`,
+          autoComplete: "country",
+          required: true,
+          value: address.country,
+          onChange: (event) => onChange({ ...address, country: event.target.value.toUpperCase() }),
+          children: checkoutCountryCodes(address.country).map((code) => /* @__PURE__ */ jsx7("option", { value: code, children: countryLabel(code, locale) }, code))
+        }
+      )
+    ] })
+  ] });
+}
+function OrderSummary({
+  cart,
+  messages
+}) {
+  return /* @__PURE__ */ jsx7("section", { className: "cat-checkout__bezel cat-checkout__summary", children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+    /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__section-heading", children: [
+      /* @__PURE__ */ jsx7(Package4, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx7("h2", { children: messages.orderSummary })
+    ] }),
+    /* @__PURE__ */ jsx7("ul", { className: "cat-checkout__items", children: cart.lineItems.map((item) => /* @__PURE__ */ jsxs7("li", { className: "cat-checkout__item", children: [
+      /* @__PURE__ */ jsxs7("span", { className: "cat-checkout__item-copy", children: [
+        item.imageUrl ? /* @__PURE__ */ jsx7("img", { src: item.imageUrl, alt: "", className: "cat-checkout__item-image" }) : /* @__PURE__ */ jsx7("div", { className: "cat-checkout__item-image cat-checkout__item-image--placeholder", children: /* @__PURE__ */ jsx7(Package4, { size: 16, strokeWidth: ICON_STROKE, "aria-hidden": "true" }) }),
+        /* @__PURE__ */ jsxs7("span", { children: [
+          item.name,
+          /* @__PURE__ */ jsxs7("small", { children: [
+            "\xD7 ",
+            item.quantity
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx7("strong", { children: item.price?.formatted ?? "\u2014" })
+    ] }, item.id)) }),
+    /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__summary-total", children: [
+      /* @__PURE__ */ jsx7("span", { children: messages.total }),
+      /* @__PURE__ */ jsx7("strong", { children: cart.totalPrice.formatted })
+    ] })
+  ] }) });
+}
+function ShippingMethodCard({
+  method,
+  selected,
+  disabled,
+  onSelect
+}) {
+  return /* @__PURE__ */ jsxs7(
+    "button",
+    {
+      type: "button",
+      className: `cat-checkout__shipping-card${selected ? " cat-checkout__shipping-card--selected" : ""}`,
+      disabled,
+      "aria-pressed": selected,
+      onClick: onSelect,
+      children: [
+        /* @__PURE__ */ jsxs7("span", { className: "cat-checkout__shipping-copy", children: [
+          /* @__PURE__ */ jsx7("strong", { children: method.name }),
+          method.description ? /* @__PURE__ */ jsx7("small", { children: method.description }) : null
+        ] }),
+        /* @__PURE__ */ jsxs7("span", { className: "cat-checkout__shipping-price", children: [
+          method.price?.formatted ?? "",
+          /* @__PURE__ */ jsx7("span", { className: "cat-checkout__shipping-check", "aria-hidden": "true", children: selected ? /* @__PURE__ */ jsx7(Check3, { size: 14, strokeWidth: ICON_STROKE }) : null })
+        ] })
+      ]
+    }
+  );
+}
+function CommerceAICheckout({
+  apiBaseUrl,
+  theme = "auto",
+  catalogLocale,
+  currency,
+  country = "DE",
+  messages: messageOverrides,
+  continueShoppingHref = "/",
+  orderStatusHref = "/orders",
+  onOrderPlaced
+}) {
+  const messages = useMemo4(
+    () => resolveCommerceAISearchMessages(messageOverrides),
+    [messageOverrides]
+  );
+  const cart = useCart({ apiBaseUrl, catalogLocale, currency, country });
+  const [shippingAddress, setShippingAddress] = useState9(
+    () => createEmptyAddress(country)
+  );
+  const [billingAddress, setBillingAddress] = useState9(
+    () => createEmptyAddress(country)
+  );
+  const [billingMatchesShipping, setBillingMatchesShipping] = useState9(true);
+  const [shippingMethods, setShippingMethods] = useState9([]);
+  const [hasLoadedShippingMethods, setHasLoadedShippingMethods] = useState9(false);
+  const [selectedShippingMethodId, setSelectedShippingMethodId] = useState9("");
+  const [paymentMethods, setPaymentMethods] = useState9([]);
+  const [paymentMethodsLoaded, setPaymentMethodsLoaded] = useState9(false);
+  const [selectedPaymentMethod, setSelectedPaymentMethod] = useState9("");
+  const [authorizedPayment, setAuthorizedPayment] = useState9(null);
+  const [order, setOrder] = useState9(null);
+  const [isPlacingOrder, setIsPlacingOrder] = useState9(false);
+  const [isPending, startTransition] = useTransition();
+  function handleAddressSubmit(event) {
+    event.preventDefault();
+    startTransition(async () => {
+      const updated = await cart.setAddresses(
+        shippingAddress,
+        billingMatchesShipping ? void 0 : billingAddress
+      );
+      if (!updated) {
+        return;
+      }
+      const [methods, payments] = await Promise.all([
+        cart.getShippingMethods(),
+        cart.getPaymentMethods()
+      ]);
+      if (methods === null) {
+        return;
+      }
+      setShippingMethods(methods);
+      setHasLoadedShippingMethods(true);
+      setSelectedShippingMethodId(updated.shippingMethod?.id ?? "");
+      if (payments === null) {
+        setPaymentMethods([]);
+        setPaymentMethodsLoaded(false);
+      } else {
+        setPaymentMethods(payments);
+        setPaymentMethodsLoaded(true);
+      }
+      setSelectedPaymentMethod("");
+      setAuthorizedPayment(null);
+    });
+  }
+  function selectShippingMethod(methodId) {
+    startTransition(async () => {
+      const updated = await cart.setShippingMethod(methodId);
+      if (updated) {
+        setSelectedShippingMethodId(methodId);
+        setSelectedPaymentMethod("");
+        setAuthorizedPayment(null);
+      }
+    });
+  }
+  function selectPaymentMethod(method) {
+    if (authorizedPayment?.status === "authorized" && authorizedPayment.method === method && authorizedPayment.amount.amount === cart.cart?.totalPrice.amount && authorizedPayment.amount.currency === cart.cart?.totalPrice.currency) {
+      return;
+    }
+    startTransition(async () => {
+      const payment = await cart.authorizePayment(method);
+      if (payment?.status === "authorized") {
+        setSelectedPaymentMethod(method);
+        setAuthorizedPayment(payment);
+      }
+    });
+  }
+  function placeOrder() {
+    setIsPlacingOrder(true);
+    startTransition(async () => {
+      try {
+        const placed = await cart.placeOrder();
+        if (placed) {
+          setOrder(placed);
+          onOrderPlaced?.(placed);
+        }
+      } finally {
+        setIsPlacingOrder(false);
+      }
+    });
+  }
+  if (order) {
+    return /* @__PURE__ */ jsx7("main", { className: "cat-root cat-checkout", "data-theme": theme, children: /* @__PURE__ */ jsx7("section", { className: "cat-checkout__success cat-checkout__bezel", children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+      /* @__PURE__ */ jsx7("span", { className: "cat-checkout__success-icon", "aria-hidden": "true", children: /* @__PURE__ */ jsx7(Check3, { size: 24, strokeWidth: ICON_STROKE }) }),
+      /* @__PURE__ */ jsx7("p", { className: "cat-checkout__eyebrow", children: messages.checkout }),
+      /* @__PURE__ */ jsx7("h1", { children: messages.orderPlaced }),
+      /* @__PURE__ */ jsx7("strong", { children: order.orderNumber ?? order.id }),
+      (order.orderNumber || order.id) && orderStatusHref ? /* @__PURE__ */ jsx7(
+        "a",
+        {
+          className: "cat-checkout__back",
+          href: `${orderStatusHref}?orderNumber=${encodeURIComponent(order.orderNumber ?? order.id)}`,
+          children: messages.viewOrderStatus
+        }
+      ) : null,
+      /* @__PURE__ */ jsxs7("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+        /* @__PURE__ */ jsx7(ArrowLeft, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        messages.continueShopping
+      ] })
+    ] }) }) });
+  }
+  if (!cart.cart) {
+    return /* @__PURE__ */ jsx7("main", { className: "cat-root cat-checkout", "data-theme": theme, children: /* @__PURE__ */ jsx7("section", { className: "cat-checkout__empty cat-checkout__bezel", children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+      /* @__PURE__ */ jsx7(Package4, { size: 24, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx7("h1", { children: cart.isLoading || !cart.anonymousId ? messages.searching : messages.emptyCart }),
+      /* @__PURE__ */ jsxs7("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+        /* @__PURE__ */ jsx7(ArrowLeft, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        messages.continueShopping
+      ] })
+    ] }) }) });
+  }
+  const checkoutBusy = isPending || cart.isMutating || isPlacingOrder;
+  const shippingReady = hasLoadedShippingMethods && (shippingMethods.length === 0 || Boolean(selectedShippingMethodId));
+  const paymentMethodsUnknown = hasLoadedShippingMethods && !paymentMethodsLoaded;
+  const paymentOffered = paymentMethodsLoaded && paymentMethods.length > 0;
+  const paymentRequired = paymentMethodsUnknown || paymentOffered;
+  const paymentReady = !paymentRequired || authorizedPayment?.status === "authorized" && authorizedPayment.amount.amount === cart.cart.totalPrice.amount && authorizedPayment.amount.currency === cart.cart.totalPrice.currency;
+  const canPlaceOrder = shippingReady && paymentReady;
+  const placeOrderHint = !canPlaceOrder ? !hasLoadedShippingMethods ? messages.completeAddressToContinue : shippingMethods.length > 0 && !selectedShippingMethodId ? messages.selectDeliveryToContinue : paymentRequired && !paymentReady ? messages.selectPaymentToContinue : void 0 : void 0;
+  return /* @__PURE__ */ jsxs7("main", { className: "cat-root cat-checkout", "data-theme": theme, children: [
+    /* @__PURE__ */ jsxs7("header", { className: "cat-checkout__intro", children: [
+      /* @__PURE__ */ jsx7("p", { className: "cat-checkout__eyebrow", children: messages.checkout }),
+      /* @__PURE__ */ jsx7("h1", { children: messages.checkoutTitle }),
+      /* @__PURE__ */ jsxs7("ol", { className: "cat-checkout__steps", children: [
+        /* @__PURE__ */ jsx7(
+          "li",
+          {
+            className: `cat-checkout__step${hasLoadedShippingMethods ? "" : " cat-checkout__step--current"}`,
+            "aria-current": hasLoadedShippingMethods ? void 0 : "step",
+            children: messages.checkoutStepAddress
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          "li",
+          {
+            className: `cat-checkout__step${hasLoadedShippingMethods ? " cat-checkout__step--current" : ""}`,
+            "aria-current": hasLoadedShippingMethods && !paymentRequired ? "step" : void 0,
+            children: messages.checkoutStepDelivery
+          }
+        ),
+        paymentRequired ? /* @__PURE__ */ jsx7(
+          "li",
+          {
+            className: `cat-checkout__step${hasLoadedShippingMethods ? " cat-checkout__step--current" : ""}`,
+            "aria-current": hasLoadedShippingMethods ? "step" : void 0,
+            children: messages.checkoutStepPayment
+          }
+        ) : null
+      ] })
+    ] }),
+    cart.error ? /* @__PURE__ */ jsx7("div", { className: "cat-status cat-status--error", role: "alert", children: cart.error || messages.checkoutFailed }) : null,
+    /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__layout", children: [
+      /* @__PURE__ */ jsx7(OrderSummary, { cart: cart.cart, messages }),
+      /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__flow", children: [
+        /* @__PURE__ */ jsx7(
+          "form",
+          {
+            className: "cat-checkout__bezel",
+            onSubmit: handleAddressSubmit,
+            children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+              /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__section-heading", children: [
+                /* @__PURE__ */ jsx7(MapPin, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+                /* @__PURE__ */ jsx7("h2", { children: messages.shippingAddress })
+              ] }),
+              /* @__PURE__ */ jsx7(
+                AddressFields,
+                {
+                  address: shippingAddress,
+                  messages,
+                  prefix: "shipping",
+                  locale: catalogLocale,
+                  onChange: setShippingAddress
+                }
+              ),
+              /* @__PURE__ */ jsxs7("label", { className: "cat-checkout__checkbox", children: [
+                /* @__PURE__ */ jsx7(
+                  "input",
+                  {
+                    type: "checkbox",
+                    checked: billingMatchesShipping,
+                    onChange: (event) => setBillingMatchesShipping(event.target.checked)
+                  }
+                ),
+                /* @__PURE__ */ jsx7("span", { children: messages.billingSameAsShipping })
+              ] }),
+              !billingMatchesShipping ? /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__billing", children: [
+                /* @__PURE__ */ jsx7("h3", { children: messages.billingAddress }),
+                /* @__PURE__ */ jsx7(
+                  AddressFields,
+                  {
+                    address: billingAddress,
+                    messages,
+                    prefix: "billing",
+                    locale: catalogLocale,
+                    onChange: setBillingAddress
+                  }
+                )
+              ] }) : null,
+              /* @__PURE__ */ jsx7(
+                "button",
+                {
+                  className: "cat-checkout__secondary",
+                  type: "submit",
+                  disabled: checkoutBusy,
+                  children: messages.continueToDelivery
+                }
+              )
+            ] })
+          }
+        ),
+        hasLoadedShippingMethods ? /* @__PURE__ */ jsx7("section", { className: "cat-checkout__bezel", children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+          /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__section-heading", children: [
+            /* @__PURE__ */ jsx7(Package4, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx7("h2", { children: messages.shippingMethod })
+          ] }),
+          shippingMethods.length > 0 ? /* @__PURE__ */ jsx7(
+            "div",
+            {
+              className: "cat-checkout__shipping-methods",
+              "aria-label": messages.selectShippingMethod,
+              children: shippingMethods.map((method) => /* @__PURE__ */ jsx7(
+                ShippingMethodCard,
+                {
+                  method,
+                  selected: selectedShippingMethodId === method.id,
+                  disabled: checkoutBusy,
+                  onSelect: () => selectShippingMethod(method.id)
+                },
+                method.id
+              ))
+            }
+          ) : /* @__PURE__ */ jsx7("p", { className: "cat-checkout__empty-methods", children: messages.noShippingMethods })
+        ] }) }) : null,
+        shippingReady && paymentRequired ? /* @__PURE__ */ jsx7("section", { className: "cat-checkout__bezel", children: /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__core", children: [
+          /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__section-heading", children: [
+            /* @__PURE__ */ jsx7(CreditCard, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx7("h2", { children: messages.paymentMethod })
+          ] }),
+          /* @__PURE__ */ jsx7(
+            "div",
+            {
+              className: "cat-checkout__shipping-methods",
+              "aria-label": messages.selectPaymentMethod,
+              children: paymentMethods.map((method) => /* @__PURE__ */ jsxs7(
+                "button",
+                {
+                  type: "button",
+                  className: `cat-checkout__shipping-card${selectedPaymentMethod === method.method ? " cat-checkout__shipping-card--selected" : ""}`,
+                  disabled: checkoutBusy,
+                  "aria-pressed": selectedPaymentMethod === method.method,
+                  onClick: () => selectPaymentMethod(method.method),
+                  children: [
+                    /* @__PURE__ */ jsxs7("span", { className: "cat-checkout__shipping-copy", children: [
+                      /* @__PURE__ */ jsx7("strong", { children: method.name }),
+                      method.description ? /* @__PURE__ */ jsx7("small", { children: method.description }) : null
+                    ] }),
+                    /* @__PURE__ */ jsxs7("span", { className: "cat-checkout__shipping-price", children: [
+                      authorizedPayment?.status === "authorized" && authorizedPayment.method === method.method ? messages.paymentAuthorized : "",
+                      /* @__PURE__ */ jsx7("span", { className: "cat-checkout__shipping-check", "aria-hidden": "true", children: authorizedPayment?.status === "authorized" && authorizedPayment.method === method.method ? /* @__PURE__ */ jsx7(Check3, { size: 14, strokeWidth: ICON_STROKE }) : null })
+                    ] })
+                  ]
+                },
+                method.method
+              ))
+            }
+          )
+        ] }) }) : null
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7("div", { className: "cat-checkout__place-island", children: [
+      /* @__PURE__ */ jsxs7(
+        "button",
+        {
+          type: "button",
+          className: "cat-checkout-cta",
+          disabled: !canPlaceOrder || checkoutBusy,
+          onClick: placeOrder,
+          "aria-busy": checkoutBusy && canPlaceOrder ? true : void 0,
+          "aria-describedby": placeOrderHint ? "cat-checkout-place-hint" : void 0,
+          children: [
+            /* @__PURE__ */ jsx7("span", { children: isPlacingOrder ? messages.placingOrder : messages.placeOrder }),
+            /* @__PURE__ */ jsx7("span", { className: "cat-checkout-cta__icon", "aria-hidden": "true", children: /* @__PURE__ */ jsx7(ArrowRight2, { size: 16, strokeWidth: ICON_STROKE }) })
+          ]
+        }
+      ),
+      placeOrderHint ? /* @__PURE__ */ jsx7("p", { id: "cat-checkout-place-hint", className: "cat-checkout__place-hint", children: placeOrderHint }) : null
+    ] })
+  ] });
+}
+
+// src/components/CommerceAIOrderStatus.tsx
+import { useEffect as useEffect7, useMemo as useMemo5, useState as useState10 } from "react";
+import { ArrowLeft as ArrowLeft2, Package as Package5, Truck } from "lucide-react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function formatAddress(address) {
+  return [
+    `${address.firstName} ${address.lastName}`,
+    address.streetName,
+    address.additionalStreetInfo,
+    `${address.postalCode} ${address.city}`,
+    address.country
+  ].filter(Boolean).join(", ");
+}
+function formatPlacedAt(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return iso;
+  }
+  const utc = date.toISOString();
+  return `${utc.slice(0, 10)} ${utc.slice(11, 16)} UTC`;
+}
+function orderHref(orderStatusHref, orderNumber) {
+  const separator = orderStatusHref.includes("?") ? "&" : "?";
+  return `${orderStatusHref}${separator}orderNumber=${encodeURIComponent(orderNumber)}`;
+}
+function StatusBadge({ label, value }) {
+  if (!value) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs8("span", { className: "cat-order-status__badge", children: [
+    /* @__PURE__ */ jsx8("small", { children: label }),
+    value
+  ] });
+}
+function CommerceAIOrderStatus({
+  apiBaseUrl,
+  orderNumber = "",
+  theme = "auto",
+  catalogLocale,
+  currency,
+  country,
+  messages: messageOverrides,
+  continueShoppingHref = "/",
+  orderStatusHref = "/orders"
+}) {
+  const messages = useMemo5(
+    () => resolveCommerceAISearchMessages(messageOverrides),
+    [messageOverrides]
+  );
+  const cart = useCart({ apiBaseUrl, catalogLocale, currency, country });
+  const trimmedNumber = orderNumber.trim();
+  const [order, setOrder] = useState10(null);
+  const [orders, setOrders] = useState10(null);
+  const [loaded, setLoaded] = useState10(false);
+  useEffect7(() => {
+    if (!cart.anonymousId) {
+      return;
+    }
+    let cancelled = false;
+    setLoaded(false);
+    setOrder(null);
+    setOrders(null);
+    const load = trimmedNumber ? cart.getOrder(trimmedNumber).then((next) => {
+      if (!cancelled) {
+        setOrder(next);
+        setLoaded(true);
+      }
+    }) : cart.listOrders().then((next) => {
+      if (!cancelled) {
+        setOrders(next);
+        setLoaded(true);
+      }
+    });
+    void load;
+    return () => {
+      cancelled = true;
+    };
+  }, [cart.anonymousId, cart.getOrder, cart.listOrders, trimmedNumber]);
+  if (!loaded || cart.isLoading) {
+    return /* @__PURE__ */ jsx8("main", { className: "cat-root cat-checkout", "data-theme": theme, children: /* @__PURE__ */ jsx8("section", { className: "cat-checkout__empty cat-checkout__bezel", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+      /* @__PURE__ */ jsx8(Package5, { size: 24, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx8("h1", { children: messages.searching })
+    ] }) }) });
+  }
+  if (!trimmedNumber) {
+    if (!orders?.length) {
+      return /* @__PURE__ */ jsx8("main", { className: "cat-root cat-checkout", "data-theme": theme, children: /* @__PURE__ */ jsx8("section", { className: "cat-checkout__empty cat-checkout__bezel", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+        /* @__PURE__ */ jsx8(Package5, { size: 24, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx8("h1", { children: messages.noOrdersYet }),
+        /* @__PURE__ */ jsxs8("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+          /* @__PURE__ */ jsx8(ArrowLeft2, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+          messages.continueShopping
+        ] })
+      ] }) }) });
+    }
+    return /* @__PURE__ */ jsxs8("main", { className: "cat-root cat-checkout", "data-theme": theme, children: [
+      /* @__PURE__ */ jsxs8("header", { className: "cat-checkout__intro", children: [
+        /* @__PURE__ */ jsx8("p", { className: "cat-checkout__eyebrow", children: messages.orderStatus }),
+        /* @__PURE__ */ jsx8("h1", { children: messages.yourOrders })
+      ] }),
+      cart.error ? /* @__PURE__ */ jsx8("div", { className: "cat-status cat-status--error", role: "alert", children: cart.error }) : null,
+      /* @__PURE__ */ jsx8("section", { className: "cat-checkout__bezel cat-checkout__summary", children: /* @__PURE__ */ jsx8("div", { className: "cat-checkout__core", children: /* @__PURE__ */ jsx8("ul", { className: "cat-order-status__list", children: orders.map((item) => {
+        const number = item.orderNumber ?? item.id;
+        return /* @__PURE__ */ jsx8("li", { children: /* @__PURE__ */ jsxs8("a", { className: "cat-order-status__list-link", href: orderHref(orderStatusHref, number), children: [
+          /* @__PURE__ */ jsxs8("span", { className: "cat-order-status__list-copy", children: [
+            /* @__PURE__ */ jsx8("strong", { children: number }),
+            item.createdAt ? /* @__PURE__ */ jsx8("small", { children: formatPlacedAt(item.createdAt) }) : null
+          ] }),
+          /* @__PURE__ */ jsxs8("span", { className: "cat-order-status__list-meta", children: [
+            item.orderState ? /* @__PURE__ */ jsx8("small", { children: item.orderState }) : null,
+            /* @__PURE__ */ jsx8("strong", { children: item.totalPrice.formatted })
+          ] })
+        ] }) }, item.id);
+      }) }) }) }),
+      /* @__PURE__ */ jsxs8("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+        /* @__PURE__ */ jsx8(ArrowLeft2, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        messages.continueShopping
+      ] })
+    ] });
+  }
+  if (!order) {
+    return /* @__PURE__ */ jsx8("main", { className: "cat-root cat-checkout", "data-theme": theme, children: /* @__PURE__ */ jsx8("section", { className: "cat-checkout__empty cat-checkout__bezel", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+      /* @__PURE__ */ jsx8(Package5, { size: 24, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx8("h1", { children: messages.orderNotFound }),
+      /* @__PURE__ */ jsxs8("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+        /* @__PURE__ */ jsx8(ArrowLeft2, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+        messages.continueShopping
+      ] })
+    ] }) }) });
+  }
+  return /* @__PURE__ */ jsxs8("main", { className: "cat-root cat-checkout", "data-theme": theme, children: [
+    /* @__PURE__ */ jsxs8("header", { className: "cat-checkout__intro", children: [
+      /* @__PURE__ */ jsx8("p", { className: "cat-checkout__eyebrow", children: messages.orderStatus }),
+      /* @__PURE__ */ jsx8("h1", { children: order.orderNumber ?? order.id }),
+      /* @__PURE__ */ jsxs8("div", { className: "cat-order-status__badges", children: [
+        /* @__PURE__ */ jsx8(StatusBadge, { label: messages.orderStatus, value: order.orderState }),
+        /* @__PURE__ */ jsx8(StatusBadge, { label: messages.paymentStateLabel, value: order.paymentState }),
+        /* @__PURE__ */ jsx8(StatusBadge, { label: messages.shipmentStateLabel, value: order.shipmentState })
+      ] }),
+      order.createdAt ? /* @__PURE__ */ jsxs8("p", { className: "cat-order-status__placed", children: [
+        messages.orderPlacedAt,
+        " ",
+        formatPlacedAt(order.createdAt)
+      ] }) : null
+    ] }),
+    cart.error ? /* @__PURE__ */ jsx8("div", { className: "cat-status cat-status--error", role: "alert", children: cart.error }) : null,
+    /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__layout", children: [
+      /* @__PURE__ */ jsx8("section", { className: "cat-checkout__bezel cat-checkout__summary", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+        /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__section-heading", children: [
+          /* @__PURE__ */ jsx8(Package5, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx8("h2", { children: messages.orderSummary })
+        ] }),
+        /* @__PURE__ */ jsx8("ul", { className: "cat-checkout__items", children: order.lineItems.map((item) => /* @__PURE__ */ jsxs8("li", { className: "cat-checkout__item", children: [
+          /* @__PURE__ */ jsxs8("span", { className: "cat-checkout__item-copy", children: [
+            item.imageUrl ? /* @__PURE__ */ jsx8("img", { src: item.imageUrl, alt: "", className: "cat-checkout__item-image" }) : /* @__PURE__ */ jsx8("div", { className: "cat-checkout__item-image cat-checkout__item-image--placeholder", children: /* @__PURE__ */ jsx8(Package5, { size: 16, strokeWidth: ICON_STROKE, "aria-hidden": "true" }) }),
+            /* @__PURE__ */ jsxs8("span", { children: [
+              item.name,
+              /* @__PURE__ */ jsxs8("small", { children: [
+                "\xD7 ",
+                item.quantity
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx8("strong", { children: item.totalPrice?.formatted ?? item.price?.formatted ?? "\u2014" })
+        ] }, item.id)) }),
+        /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__summary-total", children: [
+          /* @__PURE__ */ jsx8("span", { children: messages.total }),
+          /* @__PURE__ */ jsx8("strong", { children: order.totalPrice.formatted })
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__flow", children: [
+        order.shippingAddress ? /* @__PURE__ */ jsx8("section", { className: "cat-checkout__bezel", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+          /* @__PURE__ */ jsx8("h2", { children: messages.shippingAddress }),
+          /* @__PURE__ */ jsx8("p", { className: "cat-order-status__copy", children: formatAddress(order.shippingAddress) }),
+          order.shippingMethod ? /* @__PURE__ */ jsx8("p", { className: "cat-order-status__copy", children: order.shippingMethod.name }) : null
+        ] }) }) : null,
+        /* @__PURE__ */ jsx8("section", { className: "cat-checkout__bezel", children: /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__core", children: [
+          /* @__PURE__ */ jsxs8("div", { className: "cat-checkout__section-heading", children: [
+            /* @__PURE__ */ jsx8(Truck, { size: 18, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx8("h2", { children: messages.shipmentStateLabel })
+          ] }),
+          order.deliveries?.length ? /* @__PURE__ */ jsx8("ul", { className: "cat-order-status__tracking", children: order.deliveries.map((delivery) => /* @__PURE__ */ jsxs8("li", { children: [
+            /* @__PURE__ */ jsx8("strong", { children: messages.trackingNumber }),
+            /* @__PURE__ */ jsx8("span", { children: delivery.trackingId ?? "\u2014" }),
+            delivery.carrier ? /* @__PURE__ */ jsxs8("small", { children: [
+              messages.carrier,
+              ": ",
+              delivery.carrier
+            ] }) : null
+          ] }, delivery.id)) }) : /* @__PURE__ */ jsx8("p", { className: "cat-checkout__empty-methods", children: messages.noTrackingYet })
+        ] }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs8("a", { className: "cat-checkout__back", href: continueShoppingHref, children: [
+      /* @__PURE__ */ jsx8(ArrowLeft2, { size: 15, strokeWidth: ICON_STROKE, "aria-hidden": "true" }),
+      messages.continueShopping
+    ] })
+  ] });
+}
+
+// src/hooks/useTheme.ts
+import { useEffect as useEffect8, useState as useState11 } from "react";
+function useTheme(theme = "auto") {
+  const [resolved, setResolved] = useState11("light");
+  useEffect8(() => {
+    if (theme === "light" || theme === "dark") {
+      setResolved(theme);
+      return;
+    }
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const update = () => setResolved(media.matches ? "dark" : "light");
+    update();
+    media.addEventListener("change", update);
+    return () => media.removeEventListener("change", update);
+  }, [theme]);
+  return theme === "auto" ? "auto" : resolved;
+}
+function useResolvedTheme(theme = "auto") {
+  const [resolved, setResolved] = useState11("light");
+  useEffect8(() => {
+    if (theme !== "auto") {
+      setResolved(theme);
+      return;
+    }
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const update = () => setResolved(media.matches ? "dark" : "light");
+    update();
+    media.addEventListener("change", update);
+    return () => media.removeEventListener("change", update);
+  }, [theme]);
+  return theme === "auto" ? "auto" : resolved;
+}
+export {
+  CART_SESSION_HEADER,
+  CommerceAICheckout,
+  CommerceAIOrderStatus,
+  CommerceAISearch,
+  DEFAULT_COMMERCE_AI_SEARCH_MESSAGES,
+  MissionResults,
+  resolveCommerceAISearchMessages,
+  useCart,
+  useCommerceAISearch,
+  useResolvedTheme,
+  useTheme,
+  useVoiceSearch
+};
+//# sourceMappingURL=index.js.map