@kotao/storefront 0.2.0

package/dist/chunk-U5677AEA.js

@@ -0,0 +1,1690 @@
+import { CONSENT_BUCKETS, readConsentCookie, CART_FORM_ACTIONS } from './chunk-OGWYTYYS.js';
+import { SHOP_HEADER, SHOP_SIGNATURE_HEADER, signShopContext } from '@kotao/storefront-contracts';
+
+// src/cache/cache.ts
+var CacheNone = () => ({ mode: "none", maxAge: 0, staleWhileRevalidate: 0 });
+var CacheShort = (o) => ({
+  mode: "short",
+  maxAge: o?.maxAge ?? 1,
+  staleWhileRevalidate: o?.staleWhileRevalidate ?? 9
+});
+var CacheLong = (o) => ({
+  mode: "long",
+  maxAge: o?.maxAge ?? 3600,
+  staleWhileRevalidate: o?.staleWhileRevalidate ?? 82800
+});
+var CacheCustom = (s) => ({
+  mode: "custom",
+  ...s
+});
+var StorefrontDefaultCache = () => ({
+  mode: "custom",
+  maxAge: 1,
+  staleWhileRevalidate: 86399
+});
+function generateCacheControlHeader(strategy) {
+  if (strategy.mode === "none") return "no-store";
+  return `public, max-age=${String(strategy.maxAge)}, stale-while-revalidate=${String(strategy.staleWhileRevalidate)}`;
+}
+var requestFor = (key) => new Request(`https://kotao.cache/${encodeURIComponent(key)}`);
+function createCache(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const cache = opts.cache;
+  const read = async (key) => {
+    const res = await cache.match(requestFor(key));
+    if (!res) return null;
+    try {
+      return await res.json();
+    } catch {
+      return null;
+    }
+  };
+  const write = async (key, value, strategy) => {
+    const body = { value, storedAt: now() };
+    const ttl = strategy.maxAge + strategy.staleWhileRevalidate;
+    await cache.put(
+      requestFor(key),
+      new Response(JSON.stringify(body), {
+        headers: { "content-type": "application/json", "cache-control": `max-age=${String(ttl)}` }
+      })
+    );
+  };
+  return {
+    raw: cache,
+    async run(key, strategy, fn) {
+      if (strategy.mode === "none") return fn();
+      const stored = await read(key);
+      if (stored) {
+        const ageSec = (now() - stored.storedAt) / 1e3;
+        if (ageSec <= strategy.maxAge) return stored.value;
+        if (ageSec <= strategy.maxAge + strategy.staleWhileRevalidate) {
+          opts.waitUntil(
+            (async () => {
+              const fresh = await fn();
+              await write(key, fresh, strategy);
+            })()
+          );
+          return stored.value;
+        }
+      }
+      const value = await fn();
+      opts.waitUntil(write(key, value, strategy));
+      return value;
+    }
+  };
+}
+
+// src/cart/cookie.ts
+var CART_ID_COOKIE = "kotao_cart";
+var CART_MAX_AGE = 60 * 60 * 24 * 30;
+function readCartIdCookie(cookieHeader) {
+  if (cookieHeader == null || cookieHeader === "") return null;
+  const match = cookieHeader.split(";").map((part) => part.trim()).find((part) => part.startsWith(`${CART_ID_COOKIE}=`));
+  if (match === void 0) return null;
+  const value = decodeURIComponent(match.slice(CART_ID_COOKIE.length + 1));
+  return value === "" ? null : value;
+}
+function buildCartIdCookie(cartId) {
+  return `${CART_ID_COOKIE}=${encodeURIComponent(cartId)}; Path=/; Max-Age=${CART_MAX_AGE}; SameSite=Lax; Secure; HttpOnly`;
+}
+
+// src/checkout/consent.ts
+var PARAM_PREFIX = "consent_";
+var VALID_PARAM_VALUES = /* @__PURE__ */ new Set(["0", "1"]);
+var CHECKOUT_CONSENT_PARAM_PREFIX = PARAM_PREFIX;
+var CHECKOUT_CONSENT_CATEGORIES = CONSENT_BUCKETS;
+function encodeCheckoutConsent(state) {
+  assertConsentState(state);
+  const params = new URLSearchParams();
+  for (const bucket of CHECKOUT_CONSENT_CATEGORIES) {
+    params.set(paramName(bucket), state[bucket] ? "1" : "0");
+  }
+  return params;
+}
+function decodeCheckoutConsent(input) {
+  const params = input instanceof URL ? input.searchParams : typeof input === "string" ? new URLSearchParams(input) : input;
+  const decoded = {};
+  for (const bucket of CHECKOUT_CONSENT_CATEGORIES) {
+    const key = paramName(bucket);
+    const value = params.get(key);
+    if (value === null) throw new Error(`Missing checkout consent param: ${key}`);
+    if (!VALID_PARAM_VALUES.has(value)) {
+      throw new Error(`Invalid checkout consent param ${key}: expected 0 or 1`);
+    }
+    decoded[bucket] = value === "1";
+  }
+  return decoded;
+}
+function paramName(bucket) {
+  return `${PARAM_PREFIX}${bucket}`;
+}
+function assertConsentState(state) {
+  for (const bucket of CHECKOUT_CONSENT_CATEGORIES) {
+    if (typeof state[bucket] !== "boolean") {
+      throw new Error(`Invalid checkout consent state: ${bucket} must be boolean`);
+    }
+  }
+}
+
+// src/checkout/checkout-url.ts
+function resolveCheckoutUrl(options) {
+  const origin = resolveShopOrigin(options);
+  const rawCheckoutUrl = options.checkoutUrl.trim();
+  const url = parseCheckoutUrl(options.checkoutUrl, origin);
+  if (url.origin !== origin) {
+    if (!isExternalHttpsCheckoutUrl(rawCheckoutUrl, url)) {
+      throw new Error(`checkoutUrl must stay on the same origin as the shop domain (${origin})`);
+    }
+    appendConsent(url, options.consent);
+    assertNoZoneIdentityLeak(url);
+    return url.toString();
+  }
+  if (!isSameOriginCheckoutPath(url)) {
+    throw new Error(`checkoutUrl must use the Gateway-owned /checkout/* carve-out`);
+  }
+  appendConsent(url, options.consent);
+  assertNoZoneIdentityLeak(url);
+  return url.toString();
+}
+function resolveShopOrigin(options) {
+  if (options.shopDomain !== void 0) return originFromDomain(options.shopDomain);
+  if (options.requestUrl !== void 0) return originFromRequestUrl(options.requestUrl);
+  throw new Error("checkoutUrl resolution requires shopDomain or requestUrl");
+}
+function originFromDomain(shopDomain) {
+  const trimmed = shopDomain.trim();
+  if (trimmed === "") throw new Error("shopDomain must not be empty");
+  const url = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+  return url.origin;
+}
+function originFromRequestUrl(requestUrl) {
+  if (requestUrl instanceof Request) return new URL(requestUrl.url).origin;
+  return new URL(requestUrl.toString()).origin;
+}
+function parseCheckoutUrl(checkoutUrl, origin) {
+  if (checkoutUrl.trim() === "") throw new Error("checkoutUrl must not be empty");
+  if (checkoutUrl.startsWith("//")) {
+    throw new Error("checkoutUrl must stay on the same origin as the shop domain");
+  }
+  return new URL(checkoutUrl, origin);
+}
+function isSameOriginCheckoutPath(url) {
+  return url.pathname.startsWith("/checkout/");
+}
+function isExternalHttpsCheckoutUrl(rawCheckoutUrl, url) {
+  return /^https:\/\//i.test(rawCheckoutUrl) && (/^\/checkouts?\//u.test(url.pathname) || /^\/cart\/c\//u.test(url.pathname));
+}
+function appendConsent(url, consent) {
+  for (const [key, value] of encodeCheckoutConsent(consent)) {
+    url.searchParams.set(key, value);
+  }
+}
+function assertNoZoneIdentityLeak(url) {
+  for (const [key, value] of url.searchParams) {
+    const pair = `${key}=${value}`.toLowerCase();
+    if (pair.includes(".kotao.com") || pair.includes("domain=kotao.com")) {
+      throw new Error("checkout handoff URL must not carry zone-wide Kotao identity");
+    }
+  }
+}
+
+// src/checkout/design-tokens.ts
+var CHECKOUT_DESIGN_TOKEN_INPUTS = [
+  {
+    type: "url",
+    name: "checkoutLogoUrl",
+    label: "Checkout logo URL"
+  },
+  {
+    type: "text",
+    name: "checkoutLogoAlt",
+    label: "Checkout logo alt text",
+    defaultValue: ""
+  },
+  {
+    type: "color",
+    name: "checkoutColorAccent",
+    label: "Checkout accent color",
+    defaultValue: "#005bd3"
+  },
+  {
+    type: "color",
+    name: "checkoutColorBackground",
+    label: "Checkout background color",
+    defaultValue: "#ffffff"
+  },
+  {
+    type: "color",
+    name: "checkoutColorForeground",
+    label: "Checkout foreground color",
+    defaultValue: "#111827"
+  },
+  {
+    type: "font",
+    name: "checkoutFontBody",
+    label: "Checkout body font",
+    defaultValue: "Inter"
+  },
+  {
+    type: "font",
+    name: "checkoutFontHeading",
+    label: "Checkout heading font",
+    defaultValue: "Inter"
+  }
+];
+function extractCheckoutDesignTokens(snapshot) {
+  const global = snapshot.global;
+  const logoUrl = optionalString(global["checkoutLogoUrl"], "checkoutLogoUrl");
+  const logoAlt = optionalString(global["checkoutLogoAlt"], "checkoutLogoAlt");
+  return {
+    logo: logoUrl === null ? null : { src: logoUrl, altText: logoAlt },
+    colors: {
+      accent: requiredString(global["checkoutColorAccent"], "checkoutColorAccent"),
+      background: requiredString(global["checkoutColorBackground"], "checkoutColorBackground"),
+      foreground: requiredString(global["checkoutColorForeground"], "checkoutColorForeground")
+    },
+    fonts: {
+      body: requiredString(global["checkoutFontBody"], "checkoutFontBody"),
+      heading: requiredString(global["checkoutFontHeading"], "checkoutFontHeading")
+    }
+  };
+}
+function optionalString(value, key) {
+  if (value === void 0 || value === null || value === "") return null;
+  if (typeof value !== "string") throw new Error(`${key} must be a string`);
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  return trimmed;
+}
+function requiredString(value, key) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${key} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+// src/cart/queries.ts
+var CART_FRAGMENT = (
+  /* GraphQL */
+  `
+  fragment KotaoCart on Cart {
+    id
+    checkoutUrl
+    totalQuantity
+    cost {
+      subtotalAmount {
+        amount
+        currencyCode
+      }
+      totalAmount {
+        amount
+        currencyCode
+      }
+      totalTaxAmount {
+        amount
+        currencyCode
+      }
+    }
+    buyerIdentity {
+      email
+      phone
+      countryCode
+    }
+    note
+    attributes {
+      key
+      value
+    }
+    discountCodes
+    lines(first: 250) {
+      nodes {
+        id
+        quantity
+        attributes {
+          key
+          value
+        }
+        merchandise {
+          ... on ProductVariant {
+            id
+            title
+            availableForSale
+            image {
+              url
+              altText
+              width
+              height
+            }
+            price {
+              amount
+              currencyCode
+            }
+            compareAtPrice {
+              amount
+              currencyCode
+            }
+            selectedOptions {
+              name
+              value
+            }
+            product {
+              handle
+              title
+            }
+          }
+        }
+        cost {
+          amountPerQuantity {
+            amount
+            currencyCode
+          }
+          subtotalAmount {
+            amount
+            currencyCode
+          }
+          totalAmount {
+            amount
+            currencyCode
+          }
+        }
+      }
+    }
+  }
+`
+);
+var CART_QUERY = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  query KotaoCart($cartId: ID!) {
+    cart(id: $cartId) {
+      ...KotaoCart
+    }
+  }
+`
+);
+var CART_CREATE_MUTATION = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation KotaoCartCreate($input: CartInput) {
+    cartCreate(input: $input) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var CART_LINES_ADD_MUTATION = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation KotaoCartLinesAdd($cartId: ID!, $lines: [CartLineInput!]!) {
+    cartLinesAdd(cartId: $cartId, lines: $lines) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var CART_LINES_UPDATE_MUTATION = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation KotaoCartLinesUpdate($cartId: ID!, $lines: [CartLineUpdateInput!]!) {
+    cartLinesUpdate(cartId: $cartId, lines: $lines) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var CART_LINES_REMOVE_MUTATION = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation KotaoCartLinesRemove($cartId: ID!, $lineIds: [ID!]!) {
+    cartLinesRemove(cartId: $cartId, lineIds: $lineIds) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var CART_BUYER_IDENTITY_UPDATE_MUTATION = (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation KotaoCartBuyerIdentityUpdate($cartId: ID!, $buyerIdentity: CartBuyerIdentityInput!) {
+    cartBuyerIdentityUpdate(cartId: $cartId, buyerIdentity: $buyerIdentity) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var mutation = (operationName, fieldName, args, variables) => (
+  /* GraphQL */
+  `
+  ${CART_FRAGMENT}
+  mutation ${operationName}($cartId: ID!, ${variables}) {
+    ${fieldName}(cartId: $cartId, ${args}) {
+      cart {
+        ...KotaoCart
+      }
+      userErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`
+);
+var CART_DISCOUNT_CODES_UPDATE_MUTATION = mutation(
+  "CartDiscountCodesUpdate",
+  "cartDiscountCodesUpdate",
+  "discountCodes: $discountCodes",
+  "$discountCodes: [String!]!"
+);
+var CART_GIFT_CARD_CODES_ADD_MUTATION = mutation(
+  "CartGiftCardCodesAdd",
+  "cartGiftCardCodesAdd",
+  "giftCardCodes: $giftCardCodes",
+  "$giftCardCodes: [String!]!"
+);
+var CART_GIFT_CARD_CODES_REMOVE_MUTATION = mutation(
+  "CartGiftCardCodesRemove",
+  "cartGiftCardCodesRemove",
+  "giftCardCodes: $giftCardCodes",
+  "$giftCardCodes: [String!]!"
+);
+var CART_NOTE_UPDATE_MUTATION = mutation(
+  "CartNoteUpdate",
+  "cartNoteUpdate",
+  "note: $note",
+  "$note: String"
+);
+var CART_ATTRIBUTES_UPDATE_MUTATION = mutation(
+  "CartAttributesUpdate",
+  "cartAttributesUpdate",
+  "attributes: $attributes",
+  "$attributes: [AttributeInput!]!"
+);
+var CART_METAFIELDS_SET_MUTATION = mutation(
+  "CartMetafieldsSet",
+  "cartMetafieldsSet",
+  "metafields: $metafields",
+  "$metafields: [CartMetafieldInput!]!"
+);
+var CART_METAFIELDS_DELETE_MUTATION = mutation(
+  "CartMetafieldsDelete",
+  "cartMetafieldsDelete",
+  "metafields: $metafields",
+  "$metafields: [CartMetafieldIdentifierInput!]!"
+);
+var CART_DELIVERY_ADDRESSES_REPLACE_MUTATION = mutation(
+  "CartDeliveryAddressesReplace",
+  "cartDeliveryAddressesReplace",
+  "addresses: $addresses",
+  "$addresses: [CartDeliveryAddressInput!]!"
+);
+var CART_SELECTED_DELIVERY_OPTIONS_UPDATE_MUTATION = mutation(
+  "CartSelectedDeliveryOptionsUpdate",
+  "cartSelectedDeliveryOptionsUpdate",
+  "selectedDeliveryOptions: $selectedDeliveryOptions",
+  "$selectedDeliveryOptions: [CartSelectedDeliveryOptionInput!]!"
+);
+
+// src/cart/createCartHandler.ts
+function cartGetIdDefault(headers) {
+  return () => readCartIdCookie(headers.get("cookie"));
+}
+function cartSetIdDefault() {
+  return (cartId) => buildCartIdCookie(cartId);
+}
+function createCartHandler(opts) {
+  const request = "request" in opts ? opts.request : void 0;
+  let getCartId;
+  let setCartId;
+  let cartId;
+  if ("request" in opts) {
+    getCartId = () => readCartIdCookie(opts.request.headers.get("cookie"));
+    setCartId = (nextCartId) => buildCartIdCookie(nextCartId);
+    cartId = readCartIdCookie(opts.request.headers.get("cookie"));
+  } else {
+    getCartId = opts.getCartId;
+    setCartId = opts.setCartId;
+    cartId = void 0;
+  }
+  const consent = readConsentCookie(request?.headers.get("cookie"));
+  const currentCartId = async () => {
+    if (cartId !== void 0) return cartId;
+    cartId = await getCartId() ?? null;
+    return cartId;
+  };
+  const withCheckoutUrl = (cart) => {
+    if (cart === null) return null;
+    if (request === void 0) return cart;
+    return {
+      ...cart,
+      checkoutUrl: resolveCheckoutUrl({
+        checkoutUrl: cart.checkoutUrl,
+        requestUrl: request,
+        consent
+      })
+    };
+  };
+  const withCookie = async (payload) => {
+    const headers = new Headers();
+    if (payload.cart?.id) {
+      cartId = payload.cart.id;
+      appendSetCartIdHeaders(headers, await setCartId(payload.cart.id));
+    }
+    return { ...payload, cart: withCheckoutUrl(payload.cart), headers };
+  };
+  const setCartIdSync = (nextCartId) => {
+    cartId = nextCartId;
+    const headers = new Headers();
+    const value = setCartId(nextCartId);
+    if (isPromiseLike(value)) {
+      throw new Error("Hydrogen cart.setCartId requires a synchronous setCartId implementation");
+    }
+    appendSetCartIdHeaders(headers, value);
+    return headers;
+  };
+  const create = async (input = {}) => {
+    const data = await opts.storefront.mutate(
+      CART_CREATE_MUTATION,
+      { variables: { input } }
+    );
+    return withCookie(data.cartCreate);
+  };
+  const ensureCartId = async () => {
+    const id = await currentCartId();
+    if (id) return id;
+    const created = await create();
+    if (!created.cart) throw new Error("cartCreate returned no cart");
+    return created.cart.id;
+  };
+  const mutateExisting = async (document, key, variables) => {
+    const id = await ensureCartId();
+    const data = await opts.storefront.mutate(document, {
+      variables: { cartId: id, ...variables }
+    });
+    return withCookie(data[key]);
+  };
+  const handler = {
+    async get() {
+      const id = await currentCartId();
+      if (!id) return null;
+      const data = await opts.storefront.query(CART_QUERY, {
+        variables: { cartId: id }
+      });
+      return withCheckoutUrl(data.cart);
+    },
+    getCart() {
+      return handler.get();
+    },
+    create,
+    addLines: (lines) => handler.linesAdd(lines),
+    updateLines: (lines) => handler.linesUpdate(lines),
+    removeLines: (lineIds) => handler.linesRemove(lineIds),
+    updateBuyerIdentity: (buyerIdentity) => handler.buyerIdentityUpdate(buyerIdentity),
+    updateDiscountCodes: (discountCodes) => handler.discountCodesUpdate(discountCodes),
+    setCartId: setCartIdSync,
+    cartCreate: create,
+    async linesAdd(lines) {
+      if (!await currentCartId()) return create({ lines });
+      return mutateExisting(CART_LINES_ADD_MUTATION, "cartLinesAdd", { lines });
+    },
+    linesUpdate: (lines) => mutateExisting(CART_LINES_UPDATE_MUTATION, "cartLinesUpdate", { lines }),
+    linesRemove: (lineIds) => mutateExisting(CART_LINES_REMOVE_MUTATION, "cartLinesRemove", { lineIds }),
+    buyerIdentityUpdate: (buyerIdentity) => mutateExisting(CART_BUYER_IDENTITY_UPDATE_MUTATION, "cartBuyerIdentityUpdate", {
+      buyerIdentity
+    }),
+    discountCodesUpdate: (discountCodes) => mutateExisting(CART_DISCOUNT_CODES_UPDATE_MUTATION, "cartDiscountCodesUpdate", {
+      discountCodes
+    }),
+    giftCardCodesAdd: (giftCardCodes) => mutateExisting(CART_GIFT_CARD_CODES_ADD_MUTATION, "cartGiftCardCodesAdd", {
+      giftCardCodes
+    }),
+    giftCardCodesRemove: (giftCardCodes) => mutateExisting(CART_GIFT_CARD_CODES_REMOVE_MUTATION, "cartGiftCardCodesRemove", {
+      giftCardCodes
+    }),
+    noteUpdate: (note) => mutateExisting(CART_NOTE_UPDATE_MUTATION, "cartNoteUpdate", { note }),
+    attributesUpdate: (attributes) => mutateExisting(CART_ATTRIBUTES_UPDATE_MUTATION, "cartAttributesUpdate", { attributes }),
+    metafieldsSet: (metafields) => mutateExisting(CART_METAFIELDS_SET_MUTATION, "cartMetafieldsSet", { metafields }),
+    metafieldsDelete: (metafields) => mutateExisting(CART_METAFIELDS_DELETE_MUTATION, "cartMetafieldsDelete", { metafields }),
+    deliveryAddressesReplace: (addresses) => mutateExisting(CART_DELIVERY_ADDRESSES_REPLACE_MUTATION, "cartDeliveryAddressesReplace", {
+      addresses
+    }),
+    selectedDeliveryOptionsUpdate: (selectedDeliveryOptions) => mutateExisting(
+      CART_SELECTED_DELIVERY_OPTIONS_UPDATE_MUTATION,
+      "cartSelectedDeliveryOptionsUpdate",
+      { selectedDeliveryOptions }
+    ),
+    dispatch(action) {
+      switch (action.action) {
+        case CART_FORM_ACTIONS.LinesAdd:
+          return handler.linesAdd(action.inputs.lines);
+        case CART_FORM_ACTIONS.LinesUpdate:
+          return handler.linesUpdate(action.inputs.lines);
+        case CART_FORM_ACTIONS.LinesRemove:
+          return handler.linesRemove(action.inputs.lineIds);
+        case CART_FORM_ACTIONS.DiscountCodesUpdate:
+          return handler.discountCodesUpdate(action.inputs.discountCodes);
+        case CART_FORM_ACTIONS.GiftCardCodesAdd:
+          return handler.giftCardCodesAdd(action.inputs.giftCardCodes);
+        case CART_FORM_ACTIONS.GiftCardCodesRemove:
+          return handler.giftCardCodesRemove(action.inputs.giftCardCodes);
+        case CART_FORM_ACTIONS.BuyerIdentityUpdate:
+          return handler.buyerIdentityUpdate(action.inputs.buyerIdentity);
+        case CART_FORM_ACTIONS.NoteUpdate:
+          return handler.noteUpdate(action.inputs.note ?? null);
+        case CART_FORM_ACTIONS.AttributesUpdate:
+          return handler.attributesUpdate(action.inputs.attributes);
+        case CART_FORM_ACTIONS.MetafieldsSet:
+          return handler.metafieldsSet(action.inputs.metafields);
+        case CART_FORM_ACTIONS.MetafieldsDelete:
+          return handler.metafieldsDelete(action.inputs.metafields);
+        case CART_FORM_ACTIONS.DeliveryAddressesReplace:
+          return handler.deliveryAddressesReplace(action.inputs.addresses);
+        case CART_FORM_ACTIONS.SelectedDeliveryOptionsUpdate:
+          return handler.selectedDeliveryOptionsUpdate(
+            action.inputs.selectedDeliveryOptions
+          );
+      }
+    }
+  };
+  return handler;
+}
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function appendSetCartIdHeaders(headers, value) {
+  if (typeof value === "string" && value.length > 0) {
+    headers.append("set-cookie", value);
+    return;
+  }
+  if (value instanceof Headers) {
+    value.forEach((headerValue, headerName) => {
+      headers.append(headerName, headerValue);
+    });
+  }
+}
+
+// src/customer-account/session.ts
+var CUSTOMER_SESSION_COOKIE = "kotao_customer_session";
+var DEFAULT_SESSION_MAX_AGE = 60 * 60 * 24 * 30;
+var assertHostname = (hostname) => {
+  if (hostname === "" || hostname.startsWith(".") || hostname.endsWith(".")) {
+    throw new Error(`invalid shop hostname for the customer session cookie: '${hostname}'`);
+  }
+};
+function shopHostname(request) {
+  return new URL(request.url).hostname;
+}
+function buildCustomerSessionCookie(token, attrs) {
+  assertHostname(attrs.hostname);
+  const maxAge = attrs.maxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE;
+  return `${CUSTOMER_SESSION_COOKIE}=${encodeURIComponent(token)}; Domain=${attrs.hostname}; Path=/; Max-Age=${maxAge}; HttpOnly; Secure; SameSite=Lax`;
+}
+function clearCustomerSessionCookie(attrs) {
+  assertHostname(attrs.hostname);
+  return `${CUSTOMER_SESSION_COOKIE}=; Domain=${attrs.hostname}; Path=/; Max-Age=0; HttpOnly; Secure; SameSite=Lax`;
+}
+function readCustomerSessionToken(cookieHeader) {
+  if (cookieHeader === null || cookieHeader === void 0 || cookieHeader === "") return null;
+  const match = cookieHeader.split(";").map((part) => part.trim()).find((part) => part.startsWith(`${CUSTOMER_SESSION_COOKIE}=`));
+  if (match === void 0) return null;
+  const raw = match.slice(CUSTOMER_SESSION_COOKIE.length + 1);
+  if (raw === "") return null;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/customer-account/types.ts
+var CustomerAccountError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CustomerAccountError";
+    this.code = code;
+  }
+};
+
+// src/customer-account/client.ts
+var DEFAULT_PROXY_BASE = "/api/storefront";
+var DEFAULT_CUSTOMER_API_VERSION = "2026-04";
+var CUSTOMER_ACCOUNT_SCOPE = "openid email customer-account-api:full";
+var HYDROGEN_CUSTOMER_ACCOUNT_SESSION_KEY = "customerAccount";
+var SAME_ORIGIN_PATH = /^\/(?![/\\])/;
+function createCustomerAccountClient(opts) {
+  const proxyBase = opts.proxyBase ?? DEFAULT_PROXY_BASE;
+  if (!SAME_ORIGIN_PATH.test(proxyBase) || proxyBase.includes("..")) {
+    throw new Error(`customer-account proxyBase must be a same-origin path, got '${proxyBase}'`);
+  }
+  const doFetch = opts.fetch ?? fetch;
+  const cookieHeader = opts.request.headers.get("cookie");
+  const token = readCustomerSessionToken(cookieHeader);
+  const hydrogenCustomerAccountId = opts.customerAccountId?.trim();
+  const hydrogenShopId = opts.shopId?.trim();
+  const hasHydrogenCustomerAccount = hydrogenCustomerAccountId !== void 0 && hydrogenCustomerAccountId.length > 0 && hydrogenShopId !== void 0 && hydrogenShopId.length > 0;
+  const hydrogenSession = isHydrogenSessionLike(opts.session) ? opts.session : void 0;
+  const proxyGet = async (path) => {
+    try {
+      return await doFetch(`${proxyBase}${path}`, {
+        headers: token !== null ? { cookie: `${CUSTOMER_SESSION_COOKIE}=${encodeURIComponent(token)}` } : {}
+      });
+    } catch (cause) {
+      throw new CustomerAccountError(
+        "unreachable",
+        `customer-account proxy unreachable: ${cause instanceof Error ? cause.message : String(cause)}`
+      );
+    }
+  };
+  const readJson = async (res, what) => {
+    if (res.status === 401) {
+      throw new CustomerAccountError("unauthenticated", `${what}: not logged in`);
+    }
+    if (!res.ok) {
+      throw new CustomerAccountError("api_error", `${what} failed: HTTP ${res.status}`);
+    }
+    try {
+      return await res.json();
+    } catch {
+      throw new CustomerAccountError("api_error", `${what}: malformed JSON in proxy response`);
+    }
+  };
+  const proxyPost = async (path, body) => {
+    return doFetch(`${proxyBase}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  };
+  const proxyWrite = async (path, method, body) => {
+    const headers = { "content-type": "application/json" };
+    if (token !== null) headers.cookie = `${CUSTOMER_SESSION_COOKIE}=${encodeURIComponent(token)}`;
+    return doFetch(`${proxyBase}${path}`, {
+      method,
+      headers,
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  };
+  const returnTo = () => {
+    const url = new URL(opts.request.url);
+    return `${url.pathname}${url.search}`;
+  };
+  const requestHttpsOrigin = () => {
+    const url = new URL(opts.request.url);
+    return url.protocol === "http:" ? url.origin.replace(/^http:/, "https:") : url.origin;
+  };
+  const redirectResponse = (location) => new Response(null, { status: 302, headers: { location } });
+  const commitHydrogenSession = async (headers) => {
+    const cookie = await hydrogenSession?.commit?.();
+    if (cookie !== void 0 && cookie.length > 0) headers.append("set-cookie", cookie);
+  };
+  const redirectWithHydrogenSession = async (location) => {
+    const headers = new Headers({ location });
+    await commitHydrogenSession(headers);
+    return new Response(null, { status: 302, headers });
+  };
+  const readHydrogenCustomerSession = () => {
+    const value = hydrogenSession?.get(HYDROGEN_CUSTOMER_ACCOUNT_SESSION_KEY);
+    if (value === null || value === void 0 || typeof value !== "object") return null;
+    return value;
+  };
+  const setHydrogenCustomerSession = (value) => {
+    hydrogenSession?.set(HYDROGEN_CUSTOMER_ACCOUNT_SESSION_KEY, value);
+  };
+  const clearHydrogenCustomerSession = () => {
+    if (hydrogenSession?.unset !== void 0) {
+      hydrogenSession.unset(HYDROGEN_CUSTOMER_ACCOUNT_SESSION_KEY);
+      return;
+    }
+    hydrogenSession?.set(HYDROGEN_CUSTOMER_ACCOUNT_SESSION_KEY, void 0);
+  };
+  const hydrogenTokenEndpoint = () => `https://shopify.com/authentication/${hydrogenShopId}/oauth/token`;
+  const setHydrogenCustomerTokens = (tokenResponse, previous) => {
+    const refreshToken = tokenResponse.refresh_token ?? previous?.refreshToken;
+    const idToken = tokenResponse.id_token ?? previous?.idToken;
+    const nextSession = {
+      accessToken: tokenResponse.access_token,
+      expiresAt: String(Date.now() + Math.max(tokenResponse.expires_in - 120, 0) * 1e3),
+      ...refreshToken !== void 0 ? { refreshToken } : {},
+      ...idToken !== void 0 ? { idToken } : {}
+    };
+    setHydrogenCustomerSession(nextSession);
+  };
+  const refreshHydrogenAccessToken = async (sessionValue) => {
+    const refreshToken = sessionValue.refreshToken;
+    if (refreshToken === void 0 || refreshToken.length === 0) return null;
+    const body = new URLSearchParams();
+    body.set("grant_type", "refresh_token");
+    body.set("client_id", hydrogenCustomerAccountId ?? "");
+    body.set("refresh_token", refreshToken);
+    try {
+      const res = await doFetch(hydrogenTokenEndpoint(), {
+        method: "POST",
+        headers: {
+          "content-type": "application/x-www-form-urlencoded",
+          Origin: requestHttpsOrigin()
+        },
+        body
+      });
+      if (!res.ok) {
+        clearHydrogenCustomerSession();
+        return null;
+      }
+      const tokenResponse = await res.json();
+      if (typeof tokenResponse.access_token !== "string" || tokenResponse.access_token.length === 0 || typeof tokenResponse.expires_in !== "number" || !Number.isFinite(tokenResponse.expires_in)) {
+        clearHydrogenCustomerSession();
+        return null;
+      }
+      setHydrogenCustomerTokens(tokenResponse, sessionValue);
+      return tokenResponse.access_token;
+    } catch {
+      clearHydrogenCustomerSession();
+      return null;
+    }
+  };
+  const hydrogenAccessToken = async () => {
+    if (!hasHydrogenCustomerAccount) return null;
+    const sessionValue = readHydrogenCustomerSession();
+    if (sessionValue === null) return null;
+    const accessToken = sessionValue.accessToken;
+    const expiresAt = Number(sessionValue.expiresAt);
+    if (accessToken === void 0 || accessToken.length === 0) return null;
+    if (!Number.isFinite(expiresAt)) return null;
+    if (expiresAt <= Date.now()) return refreshHydrogenAccessToken(sessionValue);
+    return accessToken;
+  };
+  const loginRedirect = async () => {
+    if (hasHydrogenCustomerAccount) {
+      const state = randomOAuthToken();
+      const nonce = randomOAuthToken();
+      const codeVerifier = randomOAuthToken();
+      const codeChallenge = await sha256Base64Url(codeVerifier);
+      setHydrogenCustomerSession({
+        ...readHydrogenCustomerSession() ?? {},
+        codeVerifier,
+        state,
+        nonce,
+        redirectPath: returnTo()
+      });
+      const loginUrl = new URL(
+        `https://shopify.com/authentication/${hydrogenShopId}/oauth/authorize`
+      );
+      loginUrl.searchParams.set("client_id", hydrogenCustomerAccountId);
+      loginUrl.searchParams.set("scope", CUSTOMER_ACCOUNT_SCOPE);
+      loginUrl.searchParams.set("response_type", "code");
+      loginUrl.searchParams.set("redirect_uri", `${requestHttpsOrigin()}/account/authorize`);
+      loginUrl.searchParams.set("state", state);
+      loginUrl.searchParams.set("nonce", nonce);
+      loginUrl.searchParams.set("code_challenge", codeChallenge);
+      loginUrl.searchParams.set("code_challenge_method", "S256");
+      return redirectWithHydrogenSession(loginUrl.toString());
+    }
+    const params = new URLSearchParams({ returnTo: returnTo() });
+    return redirectResponse(`${proxyBase}/account/login?${params.toString()}`);
+  };
+  const badRequest = (message) => new Response(message, {
+    status: 400,
+    headers: { "content-type": "text/plain; charset=utf-8" }
+  });
+  const graphQLError = (message) => ({
+    data: null,
+    errors: [{ message }]
+  });
+  const proxyGraphQL = async (document, options) => {
+    const directAccessToken = await hydrogenAccessToken();
+    if (directAccessToken !== null) {
+      try {
+        const res = await doFetch(
+          `https://shopify.com/${hydrogenShopId}/account/customer/api/${DEFAULT_CUSTOMER_API_VERSION}/graphql`,
+          {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              Authorization: directAccessToken,
+              Origin: requestHttpsOrigin()
+            },
+            body: JSON.stringify({ query: document, variables: options?.variables ?? {} })
+          }
+        );
+        if (res.status === 401) {
+          clearHydrogenCustomerSession();
+          return graphQLError("not logged in");
+        }
+        if (!res.ok) return graphQLError(`customer-account query failed: HTTP ${res.status}`);
+        const body = await res.json();
+        return {
+          data: body.data ?? null,
+          ...body.errors !== void 0 ? { errors: body.errors } : {}
+        };
+      } catch (cause) {
+        return graphQLError(
+          `customer-account query failed: ${cause instanceof Error ? cause.message : String(cause)}`
+        );
+      }
+    }
+    if (token === null) return graphQLError("not logged in");
+    try {
+      const res = await proxyWrite("/account/graphql", "POST", {
+        query: document,
+        variables: options?.variables ?? {}
+      });
+      if (res.status === 401) return graphQLError("not logged in");
+      if (!res.ok) return graphQLError(`customer-account query failed: HTTP ${res.status}`);
+      const body = await res.json();
+      return {
+        data: body.data ?? null,
+        ...body.errors !== void 0 ? { errors: body.errors } : {}
+      };
+    } catch (cause) {
+      return graphQLError(
+        `customer-account query failed: ${cause instanceof Error ? cause.message : String(cause)}`
+      );
+    }
+  };
+  return {
+    query: proxyGraphQL,
+    mutate: proxyGraphQL,
+    login: loginRedirect,
+    async authorize() {
+      if (!hasHydrogenCustomerAccount) return redirectResponse("/account");
+      const url = new URL(opts.request.url);
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const sessionValue = readHydrogenCustomerSession();
+      if (code === null || state === null) {
+        clearHydrogenCustomerSession();
+        return badRequest("No code or state parameter found in the redirect URL.");
+      }
+      if (sessionValue?.state !== state) {
+        clearHydrogenCustomerSession();
+        return badRequest("The session state does not match the state parameter.");
+      }
+      if (sessionValue.codeVerifier === void 0 || sessionValue.codeVerifier.length === 0) {
+        clearHydrogenCustomerSession();
+        return badRequest("No code verifier found in the session.");
+      }
+      const body = new URLSearchParams();
+      body.set("grant_type", "authorization_code");
+      body.set("client_id", hydrogenCustomerAccountId);
+      body.set("redirect_uri", `${requestHttpsOrigin()}/account/authorize`);
+      body.set("code", code);
+      body.set("code_verifier", sessionValue.codeVerifier);
+      const res = await doFetch(
+        `https://shopify.com/authentication/${hydrogenShopId}/oauth/token`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/x-www-form-urlencoded",
+            Origin: requestHttpsOrigin()
+          },
+          body
+        }
+      );
+      if (!res.ok) {
+        return new Response(await res.text(), {
+          status: res.status,
+          headers: { "content-type": "text/html; charset=utf-8" }
+        });
+      }
+      const tokenResponse = await res.json();
+      const responseNonce = idTokenNonce(tokenResponse.id_token ?? "");
+      if (sessionValue.nonce !== responseNonce) {
+        clearHydrogenCustomerSession();
+        return badRequest(
+          `Returned nonce does not match: ${sessionValue.nonce} !== ${responseNonce}`
+        );
+      }
+      setHydrogenCustomerTokens(tokenResponse);
+      return redirectWithHydrogenSession(sessionValue.redirectPath ?? "/account");
+    },
+    async handleAuthStatus() {
+      if (await this.isLoggedIn()) return;
+      throw await loginRedirect();
+    },
+    async requestLoginCode(input) {
+      try {
+        const res = await proxyPost("/account/send", { email: input.email });
+        if (res.status === 200) return { status: "sent" };
+        if (res.status === 429) return { status: "rate_limited" };
+        return { status: "error" };
+      } catch {
+        return { status: "error" };
+      }
+    },
+    async verifyLoginCode(input) {
+      const body = { email: input.email, code: input.code };
+      if (input.returnTo !== void 0) body.returnTo = input.returnTo;
+      try {
+        return await proxyPost("/account/verify", body);
+      } catch {
+        return new Response(null, { status: 503 });
+      }
+    },
+    async logout() {
+      const headers = new Headers();
+      if (hasHydrogenCustomerAccount) {
+        const idToken = readHydrogenCustomerSession()?.idToken;
+        const postLogoutRedirectUri = requestHttpsOrigin();
+        if (idToken !== void 0 && idToken.length > 0) {
+          const logoutUrl = new URL(`https://shopify.com/authentication/${hydrogenShopId}/logout`);
+          logoutUrl.searchParams.set("id_token_hint", idToken);
+          logoutUrl.searchParams.set("post_logout_redirect_uri", postLogoutRedirectUri);
+          headers.set("location", logoutUrl.toString());
+        } else {
+          headers.set("location", "/");
+        }
+        clearHydrogenCustomerSession();
+        const destroyedCookie = await hydrogenSession?.destroy?.();
+        if (destroyedCookie !== void 0 && destroyedCookie.length > 0) {
+          headers.append("set-cookie", destroyedCookie);
+        } else {
+          await commitHydrogenSession(headers);
+        }
+      } else {
+        headers.set("location", `${proxyBase}/account/logout`);
+      }
+      headers.append(
+        "set-cookie",
+        clearCustomerSessionCookie({ hostname: shopHostname(opts.request) })
+      );
+      return new Response(null, { status: 302, headers });
+    },
+    async getAccessToken() {
+      const directAccessToken = await hydrogenAccessToken();
+      if (directAccessToken !== null) return directAccessToken;
+      return token;
+    },
+    async isLoggedIn() {
+      if (await hydrogenAccessToken() !== null) return true;
+      if (token === null) return false;
+      try {
+        const res = await proxyGet("/account");
+        return res.ok;
+      } catch {
+        return false;
+      }
+    },
+    async account() {
+      return readJson(await proxyGet("/account"), "account read");
+    },
+    async orders(options) {
+      const params = new URLSearchParams();
+      if (options?.first !== void 0) params.set("first", String(options.first));
+      if (options?.after !== void 0) params.set("after", options.after);
+      const qs = params.toString();
+      return readJson(
+        await proxyGet(`/account/orders${qs ? `?${qs}` : ""}`),
+        "orders read"
+      );
+    },
+    async addresses() {
+      return readJson(await proxyGet("/account/addresses"), "addresses read");
+    },
+    createAddress(input) {
+      return proxyWrite("/account/addresses", "POST", input);
+    },
+    updateAddress(id, input) {
+      return proxyWrite(`/account/addresses/${encodeURIComponent(id)}`, "PUT", input);
+    },
+    deleteAddress(id) {
+      return proxyWrite(`/account/addresses/${encodeURIComponent(id)}`, "DELETE");
+    }
+  };
+}
+function randomOAuthToken() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  let raw = "";
+  for (const byte of bytes) raw += String.fromCharCode(byte);
+  return base64UrlEncode(raw);
+}
+function isHydrogenSessionLike(value) {
+  return value !== null && typeof value === "object" && "get" in value && "set" in value && typeof value.get === "function" && typeof value.set === "function";
+}
+async function sha256Base64Url(value) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  let raw = "";
+  for (const byte of new Uint8Array(digest)) raw += String.fromCharCode(byte);
+  return base64UrlEncode(raw);
+}
+function base64UrlEncode(raw) {
+  return btoa(raw).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function idTokenNonce(idToken) {
+  const [, payload] = idToken.split(".");
+  if (payload === void 0 || payload.length === 0) return null;
+  try {
+    const normalized = payload.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    const decoded = JSON.parse(atob(padded));
+    return typeof decoded.nonce === "string" ? decoded.nonce : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/geo/base64url.ts
+var toBase64Url = (bytes) => {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var fromBase64Url = (s) => {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/");
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+};
+var encodeUtf8Base64Url = (text) => toBase64Url(new TextEncoder().encode(text));
+var decodeBase64UrlUtf8 = (s) => new TextDecoder().decode(fromBase64Url(s));
+
+// src/geo/geo.ts
+var GEO_HEADER = "x-kotao-geo";
+var GEO_SIGNATURE_HEADER = "x-kotao-geo-signature";
+var importKey = (key) => crypto.subtle.importKey(
+  "raw",
+  new TextEncoder().encode(key),
+  { name: "HMAC", hash: "SHA-256" },
+  false,
+  ["sign", "verify"]
+);
+var toArrayBufferView = (bytes) => {
+  const view = new Uint8Array(bytes.byteLength);
+  view.set(bytes);
+  return view;
+};
+async function signGeo(geo, key) {
+  const payload = encodeUtf8Base64Url(JSON.stringify(geo));
+  const cryptoKey = await importKey(key);
+  const sig = await crypto.subtle.sign("HMAC", cryptoKey, new TextEncoder().encode(payload));
+  return { payload, signature: toBase64Url(new Uint8Array(sig)) };
+}
+var isGeo = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  const strOrNull = (x) => x === null || typeof x === "string";
+  const numOrNull = (x) => x === null || typeof x === "number";
+  return strOrNull(o["country"]) && strOrNull(o["city"]) && strOrNull(o["colo"]) && numOrNull(o["botScore"]) && strOrNull(o["clientIp"]);
+};
+async function verifyGeo(headers, key) {
+  const payload = headers.get(GEO_HEADER);
+  const signature = headers.get(GEO_SIGNATURE_HEADER);
+  if (!payload || !signature) return null;
+  try {
+    const cryptoKey = await importKey(key);
+    const ok = await crypto.subtle.verify(
+      "HMAC",
+      cryptoKey,
+      toArrayBufferView(fromBase64Url(signature)),
+      new TextEncoder().encode(payload)
+    );
+    if (!ok) return null;
+    const parsed = JSON.parse(decodeBase64UrlUtf8(payload));
+    return isGeo(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/localization/cookie.ts
+var LOCALIZATION_COOKIE = "kotao_localization";
+var MAX_AGE = 60 * 60 * 24 * 365;
+function readLocalizationCookie(cookieHeader) {
+  if (cookieHeader == null || cookieHeader === "") return { country: null, locale: null };
+  const match = cookieHeader.split(";").map((p) => p.trim()).find((p) => p.startsWith(`${LOCALIZATION_COOKIE}=`));
+  if (match === void 0) return { country: null, locale: null };
+  const [country = "", locale = ""] = decodeURIComponent(
+    match.slice(LOCALIZATION_COOKIE.length + 1)
+  ).split("|");
+  return { country: country || null, locale: locale || null };
+}
+function buildLocalizationCookie(sel) {
+  const value = `${sel.country ?? ""}|${sel.locale ?? ""}`;
+  return `${LOCALIZATION_COOKIE}=${encodeURIComponent(value)}; Path=/; Max-Age=${MAX_AGE}; SameSite=Lax; Secure; HttpOnly`;
+}
+
+// src/localization/routing.ts
+var LOCALE_SEGMENT_RE = /^[a-z]{2}(?:-[a-zA-Z]{2,4})?$/;
+var ROUTING_LOCALE_HEADER = "x-kotao-route-locale";
+var ROUTING_ORIGINAL_PATHNAME_HEADER = "x-kotao-original-pathname";
+function splitFirstPathSegment(pathname) {
+  if (!pathname.startsWith("/")) return null;
+  const withoutSlash = pathname.slice(1);
+  const slash = withoutSlash.indexOf("/");
+  if (slash === -1) return { segment: withoutSlash, rest: "" };
+  return { segment: withoutSlash.slice(0, slash), rest: withoutSlash.slice(slash) };
+}
+function isLocalePathSegment(segment) {
+  return LOCALE_SEGMENT_RE.test(segment);
+}
+function normalizeLocaleTag(value) {
+  const [tag = ""] = (value ?? "").trim().replaceAll("_", "-").split(";", 1);
+  if (tag === "" || tag === "*") return null;
+  const [language = "", regionOrScript] = tag.split("-");
+  const base = language.toLowerCase();
+  if (!/^[a-z]{2,3}$/.test(base)) return null;
+  if (regionOrScript === void 0 || regionOrScript.length === 0) return base;
+  if (!/^[a-zA-Z0-9]{2,4}$/.test(regionOrScript)) return null;
+  const suffix = regionOrScript.length === 2 && /^[a-zA-Z]{2}$/.test(regionOrScript) ? regionOrScript.toUpperCase() : regionOrScript.length === 4 && /^[a-zA-Z]{4}$/.test(regionOrScript) ? `${regionOrScript[0].toUpperCase()}${regionOrScript.slice(1).toLowerCase()}` : regionOrScript;
+  return `${base}-${suffix}`;
+}
+function qualityFromAcceptLanguagePart(part) {
+  const params = part.split(";").slice(1);
+  const q = params.map((param) => param.trim()).find((param) => param.toLowerCase().startsWith("q="));
+  if (q === void 0) return 1;
+  const value = Number(q.slice(2));
+  return Number.isFinite(value) && value >= 0 && value <= 1 ? value : 0;
+}
+function parseAcceptLanguage(header) {
+  if (header === null || header === void 0 || header.trim().length === 0) return [];
+  return header.split(",").map((part, order) => {
+    const locale = normalizeLocaleTag(part);
+    const quality = qualityFromAcceptLanguagePart(part);
+    if (locale === null || quality <= 0) return null;
+    return { locale, quality, order };
+  }).filter((candidate) => candidate !== null).sort((left, right) => right.quality - left.quality || left.order - right.order);
+}
+function localeFromAcceptLanguage(header, availableLocales) {
+  const candidates = parseAcceptLanguage(header);
+  if (candidates.length === 0) return null;
+  const available = (availableLocales ?? []).map((locale) => {
+    const normalized = normalizeLocaleTag(locale);
+    return normalized === null ? null : { locale, normalized };
+  }).filter((entry) => entry !== null);
+  if (available.length === 0) return candidates[0].locale;
+  for (const candidate of candidates) {
+    const exact = available.find(
+      (entry) => entry.normalized.toLowerCase() === candidate.locale.toLowerCase()
+    );
+    if (exact !== void 0) return exact.locale;
+    const language = candidate.locale.split("-")[0];
+    const languageMatch = available.find((entry) => entry.normalized.split("-")[0] === language);
+    if (languageMatch !== void 0) return languageMatch.locale;
+  }
+  return null;
+}
+function localeFromPathname(pathname) {
+  const first = splitFirstPathSegment(pathname);
+  if (first === null || first.segment.length === 0) return null;
+  return isLocalePathSegment(first.segment) ? first.segment : null;
+}
+function originalPathnameFromRequest(request) {
+  const fromHeader = request.headers.get(ROUTING_ORIGINAL_PATHNAME_HEADER);
+  return fromHeader !== null && fromHeader.startsWith("/") ? fromHeader : new URL(request.url).pathname;
+}
+function localeFromRequest(request) {
+  const fromHeader = request.headers.get(ROUTING_LOCALE_HEADER);
+  if (fromHeader !== null && isLocalePathSegment(fromHeader)) return fromHeader;
+  return localeFromPathname(originalPathnameFromRequest(request));
+}
+function stripLocalePrefixFromPathname(pathname) {
+  const locale = localeFromPathname(pathname);
+  if (locale === null) return { locale: null, pathname };
+  const first = splitFirstPathSegment(pathname);
+  const rest = first?.rest ?? "";
+  return { locale, pathname: rest.length > 0 ? rest : "/" };
+}
+function stripLocalePrefixFromRequest(request) {
+  const url = new URL(request.url);
+  const stripped = stripLocalePrefixFromPathname(url.pathname);
+  if (stripped.locale === null) return request;
+  const originalPathname = url.pathname;
+  url.pathname = stripped.pathname;
+  const next = new Request(url, request);
+  next.headers.set(ROUTING_LOCALE_HEADER, stripped.locale);
+  next.headers.set(ROUTING_ORIGINAL_PATHNAME_HEADER, originalPathname);
+  return next;
+}
+function normalizeLocale(locale) {
+  const trimmed = locale?.trim() ?? "";
+  return trimmed.length > 0 && isLocalePathSegment(trimmed) ? trimmed : null;
+}
+function localizePath(path, locale, options = {}) {
+  const targetLocale = normalizeLocale(locale);
+  const primaryLocale = normalizeLocale(options.primaryLocale);
+  const url = new URL(path.startsWith("/") ? path : "/", "https://storefront.local");
+  const stripped = stripLocalePrefixFromPathname(url.pathname).pathname;
+  const suffix = `${url.search}${url.hash}`;
+  if (targetLocale === null || primaryLocale !== null && targetLocale === primaryLocale) {
+    return `${stripped}${suffix}`;
+  }
+  return `${stripped === "/" ? `/${targetLocale}` : `/${targetLocale}${stripped}`}${suffix}`;
+}
+
+// src/storefront-client/client.ts
+var hashKey = (query, variables) => `sf:${query.replace(/\s+/g, " ").trim()}:${variables ? JSON.stringify(variables) : ""}`;
+var COUNTRY_RE = /^[A-Z]{2}$/;
+var DEFAULT_HYDROGEN_STOREFRONT_API_VERSION = "2025-01";
+function endpointForStorefrontApiVersion(endpoint, version) {
+  if (version === void 0 || version.length === 0) return endpoint;
+  try {
+    const url = new URL(endpoint);
+    if (!/^\/api\/[^/]+\/graphql\.json$/u.test(url.pathname)) return endpoint;
+    url.pathname = url.pathname.replace(
+      /^\/api\/[^/]+\/graphql\.json$/u,
+      `/api/${version}/graphql.json`
+    );
+    return url.toString();
+  } catch {
+    return endpoint;
+  }
+}
+function createStorefrontClient(opts) {
+  if (isHydrogenStorefrontClientOptions(opts)) {
+    const i18n = normalizeHydrogenI18n(opts.i18n);
+    const client = createStorefrontClientCore({
+      endpoint: hydrogenStorefrontEndpoint(opts.storeDomain, opts.storefrontApiVersion),
+      token: opts.publicStorefrontToken,
+      tokenHeader: "x-shopify-storefront-access-token",
+      cache: createCache({ cache: opts.cache, waitUntil: opts.waitUntil }),
+      fetch: opts.fetch,
+      defaultStrategy: opts.defaultStrategy,
+      extraHeaders: opts.storefrontHeaders,
+      i18n
+    });
+    return attachHydrogenResult(client);
+  }
+  return attachHydrogenResult(createStorefrontClientCore(opts));
+}
+function createStorefrontClientCore(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  const defaultStrategy = opts.defaultStrategy ?? StorefrontDefaultCache();
+  const tokenHeader = opts.tokenHeader ?? "x-kotao-storefront-token";
+  const localeKey = opts.locale !== void 0 && opts.locale.length > 0 ? opts.locale : "";
+  const countryKey = opts.country !== void 0 && COUNTRY_RE.test(opts.country) ? opts.country : "";
+  const i18n = normalizeStorefrontI18n(opts.i18n, opts.locale, countryKey);
+  const execute = async (document, options) => {
+    const endpoint = endpointForStorefrontApiVersion(opts.endpoint, options?.storefrontApiVersion);
+    const headers = {
+      "content-type": "application/json",
+      ...headersRecord(opts.extraHeaders),
+      [tokenHeader]: opts.token,
+      ...opts.signedShopContextHeaders ?? {}
+    };
+    if (opts.siteId !== void 0 && opts.siteId.trim().length > 0) {
+      headers["x-kotao-site-id"] = opts.siteId;
+    }
+    if (localeKey.length > 0) {
+      headers["x-kotao-locale"] = localeKey;
+    }
+    if (countryKey.length > 0) {
+      headers["x-kotao-country"] = countryKey;
+    }
+    const res = await doFetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: document, variables: options?.variables })
+    });
+    const opName = document.replace(/\s+/g, " ").trim().slice(0, 48);
+    const raw = await res.text();
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      console.error(
+        `[storefront] /api/storefront non-JSON response: status=${res.status} content-type=${res.headers.get("content-type") ?? ""} len=${raw.length} op="${opName}" body=${raw.slice(0, 180)}`
+      );
+      throw new Error(`Storefront API returned a non-JSON response (status ${res.status})`);
+    }
+    if (!res.ok) {
+      const shopCtx = opts.signedShopContextHeaders !== void 0 ? "present" : "absent";
+      console.error(
+        `[storefront] /api/storefront HTTP ${res.status} endpoint=${endpoint} shopCtx=${shopCtx} op="${opName}" body=${raw.slice(0, 180)}`
+      );
+    }
+    if (body.errors?.length) {
+      console.error(`[storefront] GraphQL query failed: ${JSON.stringify(body.errors)}`);
+      throw new Error(body.errors.map((e) => e.message).join("; "));
+    }
+    if (body.data === void 0) {
+      console.error(
+        `[storefront] /api/storefront returned no data: status=${res.status} op="${opName}" body=${raw.slice(0, 180)}`
+      );
+      throw new Error("Storefront API returned no data");
+    }
+    return body.data;
+  };
+  return {
+    CacheNone,
+    CacheShort,
+    CacheLong,
+    CacheCustom,
+    cache: opts.cache.raw,
+    i18n,
+    query(query, options) {
+      const strategy = options?.cache ?? defaultStrategy;
+      const versionKey = options?.storefrontApiVersion ?? "";
+      return opts.cache.run(
+        `${localeKey}:${countryKey}:${versionKey}:${hashKey(query, options?.variables)}`,
+        strategy,
+        () => execute(query, options)
+      );
+    },
+    mutate(mutation2, options) {
+      return execute(mutation2, options);
+    }
+  };
+}
+function isHydrogenStorefrontClientOptions(opts) {
+  return "storeDomain" in opts && "publicStorefrontToken" in opts && "waitUntil" in opts;
+}
+function attachHydrogenResult(client) {
+  return Object.assign(client, { storefront: client });
+}
+function headersRecord(headers) {
+  if (headers === void 0) return {};
+  const result = {};
+  new Headers(headers).forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function hydrogenStorefrontEndpoint(storeDomain, version) {
+  const trimmed = storeDomain.trim();
+  if (trimmed === "") throw new Error("storeDomain must not be empty");
+  const url = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+  url.pathname = `/api/${version ?? DEFAULT_HYDROGEN_STOREFRONT_API_VERSION}/graphql.json`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function normalizeHydrogenI18n(input) {
+  const source = input ?? {};
+  const fallback = i18nFromLocale(void 0, "");
+  return {
+    ...source,
+    language: String(source.language ?? fallback.language).toUpperCase(),
+    country: String(source.country ?? fallback.country).toUpperCase(),
+    currency: String(source.currency ?? fallback.currency).toUpperCase(),
+    pathPrefix: normalizePathPrefix(source.pathPrefix ?? fallback.pathPrefix)
+  };
+}
+function normalizeStorefrontI18n(input, locale, fallbackCountry) {
+  const fallback = i18nFromLocale(locale, fallbackCountry);
+  return {
+    ...input,
+    language: String(input?.language ?? fallback.language).toUpperCase(),
+    country: String(input?.country ?? fallback.country).toUpperCase(),
+    currency: String(input?.currency ?? fallback.currency).toUpperCase(),
+    pathPrefix: normalizePathPrefix(input?.pathPrefix ?? fallback.pathPrefix)
+  };
+}
+function i18nFromLocale(locale, fallbackCountry) {
+  const trimmedLocale = locale?.trim();
+  const [language, country] = (trimmedLocale && trimmedLocale.length > 0 ? trimmedLocale : "en-us").split(/[-_]/);
+  return {
+    language: (language ?? "en").toUpperCase(),
+    country: (country ?? (fallbackCountry || "US")).toUpperCase(),
+    currency: "USD",
+    pathPrefix: pathPrefixFromLocale(trimmedLocale)
+  };
+}
+function pathPrefixFromLocale(locale) {
+  if (locale === void 0 || locale.length === 0) return "";
+  return `/${locale.toLowerCase().replaceAll("_", "-")}`;
+}
+function normalizePathPrefix(prefix) {
+  if (prefix === void 0 || prefix.trim().length === 0) return "";
+  const trimmed = prefix.trim();
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+// src/with-cache/with-cache.ts
+var createWithCache = (cache) => (key, strategy, fn) => cache.run(key, strategy, fn);
+async function localSignedShopContextHeaders(key, siteId, hostname) {
+  if (key === void 0 || key.length === 0) return void 0;
+  if (siteId === void 0 || siteId.trim().length === 0) return void 0;
+  const { payload, signature } = await signShopContext(
+    {
+      shopId: siteId,
+      ...hostname !== void 0 && hostname.length > 0 ? { hostname } : {}
+    },
+    key
+  );
+  return { [SHOP_HEADER]: payload, [SHOP_SIGNATURE_HEADER]: signature };
+}
+var CACHE_NAME = "kotao-storefront-v1";
+var CACHE_VERSION_HEADER = "x-kotao-cache-version";
+var API_LOCALE_RE = /^[a-z]{2,3}(-[a-zA-Z]{2,4})?$/;
+var API_COUNTRY_RE = /^[A-Z]{2}$/;
+var SAME_ORIGIN_PATH2 = /^\/(?![/\\])/;
+var LEGACY_DIRECT_STOREFRONT_API_ORIGIN = /^https:\/\/storefront-api\.kotao\.(?:com|dev|local)\/?$/;
+var parseLocale = (request) => {
+  return localeFromRequest(request);
+};
+function storefrontAuthHeader(env) {
+  if (env.STOREFRONT_API_TOKEN_HEADER === "x-shopify-storefront-access-token") {
+    return "x-shopify-storefront-access-token";
+  }
+  return env.STOREFRONT_API_TOKEN_HEADER === "x-api-key" ? "x-api-key" : "x-kotao-storefront-token";
+}
+function resolveStorefrontApiEndpoint(endpoint, requestUrl) {
+  const trimmed = endpoint.trim();
+  if (SAME_ORIGIN_PATH2.test(trimmed)) return new URL(trimmed, requestUrl).toString();
+  if (LEGACY_DIRECT_STOREFRONT_API_ORIGIN.test(trimmed))
+    return new URL("/api/storefront", requestUrl).toString();
+  return endpoint;
+}
+async function createKotaoContext(request, env, executionCtx, deps) {
+  const waitUntil = (p) => {
+    executionCtx.waitUntil(p);
+  };
+  const cacheVersion = request.headers.get(CACHE_VERSION_HEADER)?.trim() || "0";
+  const cacheName = `${CACHE_NAME}-${cacheVersion}`;
+  const rawCache = await (deps?.openCache ? deps.openCache(cacheName) : caches.open(cacheName));
+  const cache = createCache({ cache: rawCache, waitUntil });
+  const storefrontApiEndpoint = env.STOREFRONT_API_ENDPOINT ?? "/api/storefront";
+  const storefrontApiToken = env.STOREFRONT_API_TOKEN ?? env.PRIVATE_STOREFRONT_API_TOKEN ?? env.PUBLIC_STOREFRONT_API_TOKEN ?? "";
+  const storefrontGeoSigningKey = env.STOREFRONT_GEO_SIGNING_KEY ?? "";
+  const geo = await verifyGeo(request.headers, storefrontGeoSigningKey);
+  const resolvedEnv = {
+    ...env,
+    STOREFRONT_API_ENDPOINT: resolveStorefrontApiEndpoint(storefrontApiEndpoint, request.url),
+    STOREFRONT_API_TOKEN: storefrontApiToken,
+    STOREFRONT_GEO_SIGNING_KEY: storefrontGeoSigningKey
+  };
+  const siteId = resolvedEnv.KOTAO_SITE_ID ?? resolvedEnv.KOTAO_SHOP_ID;
+  const inboundShop = request.headers.get(SHOP_HEADER);
+  const inboundShopSignature = request.headers.get(SHOP_SIGNATURE_HEADER);
+  const signedShopContextHeaders = inboundShop !== null && inboundShopSignature !== null ? { [SHOP_HEADER]: inboundShop, [SHOP_SIGNATURE_HEADER]: inboundShopSignature } : await localSignedShopContextHeaders(
+    resolvedEnv.STOREFRONT_SHOP_CONTEXT_KEY,
+    siteId,
+    new URL(request.url).hostname
+  );
+  const pathLocale = parseLocale(request);
+  const localizationCookie = readLocalizationCookie(request.headers.get("cookie"));
+  const cookieLocale = localizationCookie.locale;
+  const browserLocale = localeFromAcceptLanguage(request.headers.get("accept-language"));
+  const selectedLocale = pathLocale ?? cookieLocale ?? browserLocale?.split("-")[0] ?? null;
+  const apiLocale = selectedLocale !== null && API_LOCALE_RE.test(selectedLocale) ? selectedLocale : void 0;
+  const cookieCountry = localizationCookie.country !== null && API_COUNTRY_RE.test(localizationCookie.country) ? localizationCookie.country : null;
+  const geoCountry = geo?.country?.trim().toUpperCase() ?? null;
+  const apiCountry = cookieCountry ?? (geoCountry !== null && API_COUNTRY_RE.test(geoCountry) ? geoCountry : null);
+  const storefront = createStorefrontClient({
+    endpoint: resolvedEnv.STOREFRONT_API_ENDPOINT,
+    token: resolvedEnv.STOREFRONT_API_TOKEN,
+    tokenHeader: storefrontAuthHeader(resolvedEnv),
+    ...siteId !== void 0 && siteId.trim().length > 0 ? { siteId } : {},
+    ...signedShopContextHeaders ? { signedShopContextHeaders } : {},
+    ...apiLocale !== void 0 ? { locale: apiLocale } : {},
+    ...apiCountry !== null ? { country: apiCountry } : {},
+    cache
+  });
+  const cart = createCartHandler({ request, storefront });
+  const contextSession = withSessionPresenceHint(
+    deps?.session,
+    readCustomerSessionToken(request.headers.get("cookie")) !== null
+  );
+  const customerAccount = createCustomerAccountClient({
+    request,
+    customerAccountId: resolvedEnv.PUBLIC_CUSTOMER_ACCOUNT_API_CLIENT_ID,
+    shopId: resolvedEnv.SHOP_ID,
+    session: contextSession
+  });
+  return {
+    storefront,
+    cart,
+    customerAccount,
+    geo,
+    withCache: createWithCache(cache),
+    locale: pathLocale,
+    // Cookie-presence hint only — the theme cannot validate the HMAC; the authoritative check is the proxy.
+    session: contextSession,
+    env: resolvedEnv,
+    waitUntil
+  };
+}
+function withSessionPresenceHint(session, isLoggedIn) {
+  if (session === void 0) return createEphemeralSession(isLoggedIn);
+  Object.defineProperty(session, "isLoggedIn", {
+    configurable: true,
+    enumerable: true,
+    value: isLoggedIn,
+    writable: true
+  });
+  return session;
+}
+function createEphemeralSession(isLoggedIn) {
+  const data = /* @__PURE__ */ new Map();
+  let isPending = false;
+  return {
+    get isPending() {
+      return isPending;
+    },
+    isLoggedIn,
+    has: (name) => data.has(name),
+    get: (name) => data.get(name),
+    flash(name, value) {
+      const previous = data.get(name);
+      if (value !== void 0) {
+        this.set(name, value);
+        return void 0;
+      }
+      this.unset(name);
+      return previous;
+    },
+    unset(name) {
+      isPending = true;
+      data.delete(name);
+    },
+    set(name, value) {
+      isPending = true;
+      data.set(name, value);
+    },
+    destroy() {
+      isPending = false;
+      data.clear();
+      return "";
+    },
+    commit() {
+      isPending = false;
+      return "";
+    }
+  };
+}
+
+export { CART_ID_COOKIE, CHECKOUT_CONSENT_CATEGORIES, CHECKOUT_CONSENT_PARAM_PREFIX, CHECKOUT_DESIGN_TOKEN_INPUTS, CUSTOMER_SESSION_COOKIE, CacheCustom, CacheLong, CacheNone, CacheShort, CustomerAccountError, DEFAULT_SESSION_MAX_AGE, GEO_HEADER, GEO_SIGNATURE_HEADER, LOCALIZATION_COOKIE, ROUTING_LOCALE_HEADER, ROUTING_ORIGINAL_PATHNAME_HEADER, StorefrontDefaultCache, buildCartIdCookie, buildCustomerSessionCookie, buildLocalizationCookie, cartGetIdDefault, cartSetIdDefault, clearCustomerSessionCookie, createCache, createCartHandler, createCustomerAccountClient, createKotaoContext, createStorefrontClient, createWithCache, decodeCheckoutConsent, encodeCheckoutConsent, extractCheckoutDesignTokens, generateCacheControlHeader, isLocalePathSegment, localeFromAcceptLanguage, localeFromPathname, localeFromRequest, localizePath, originalPathnameFromRequest, readCartIdCookie, readCustomerSessionToken, readLocalizationCookie, resolveCheckoutUrl, shopHostname, signGeo, stripLocalePrefixFromPathname, stripLocalePrefixFromRequest, verifyGeo };
+//# sourceMappingURL=chunk-U5677AEA.js.map
+//# sourceMappingURL=chunk-U5677AEA.js.map