@ekomerc/storefront 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3266 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const neverthrow = require("neverthrow");
+const errors = require("./errors.cjs");
+function createQueryCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (!entry) return null;
+      if (Date.now() > entry.expiresAt) {
+        cache.delete(key);
+        return null;
+      }
+      return entry.value;
+    },
+    set(key, value, ttl) {
+      cache.set(key, {
+        value,
+        expiresAt: Date.now() + ttl
+      });
+    },
+    clear() {
+      cache.clear();
+    }
+  };
+}
+const CART_TOKEN_KEY = "ekomerc_cart_token";
+const CUSTOMER_TOKEN_KEY = "ekomerc_customer_token";
+function createLocalStorageAdapter() {
+  return {
+    get(key) {
+      if (typeof localStorage === "undefined") return null;
+      return localStorage.getItem(key);
+    },
+    set(key, value) {
+      if (typeof localStorage === "undefined") return;
+      localStorage.setItem(key, value);
+    },
+    remove(key) {
+      if (typeof localStorage === "undefined") return;
+      localStorage.removeItem(key);
+    }
+  };
+}
+function createMemoryAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return store.get(key) ?? null;
+    },
+    set(key, value) {
+      store.set(key, value);
+    },
+    remove(key) {
+      store.delete(key);
+    }
+  };
+}
+function createDefaultAdapter() {
+  if (typeof localStorage !== "undefined") {
+    return createLocalStorageAdapter();
+  }
+  return createMemoryAdapter();
+}
+const ORDER_ITEM_FRAGMENT = `
+  id
+  productTitle
+  variantTitle
+  sku
+  quantity
+  unitPrice
+  totalPrice
+`;
+const CUSTOMER_ORDERS_QUERY = `
+query CustomerOrders($first: Int, $after: String, $last: Int, $before: String) {
+  customerOrders(first: $first, after: $after, last: $last, before: $before) {
+    edges {
+      node {
+        id
+        orderNumber
+        status
+        customerEmail
+        customerPhone
+        subtotal
+        total
+        note
+        items { ${ORDER_ITEM_FRAGMENT} }
+        createdAt
+      }
+      cursor
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+  }
+}
+`;
+const ADDRESS_FRAGMENT = `
+  id
+  label
+  firstName
+  lastName
+  addressLine1
+  addressLine2
+  city
+  postalCode
+  phone
+  isDefault
+  createdAt
+`;
+const CUSTOMER_ADDRESSES_QUERY = `
+query CustomerAddresses {
+  customerAddresses { ${ADDRESS_FRAGMENT} }
+}
+`;
+const CUSTOMER_ADDRESS_CREATE_MUTATION = `
+mutation CustomerAddressCreate($input: CustomerAddressCreateInput!) {
+  customerAddressCreate(input: $input) {
+    address { ${ADDRESS_FRAGMENT} }
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_ADDRESS_UPDATE_MUTATION = `
+mutation CustomerAddressUpdate($addressId: String!, $input: CustomerAddressUpdateInput!) {
+  customerAddressUpdate(addressId: $addressId, input: $input) {
+    address { ${ADDRESS_FRAGMENT} }
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_ADDRESS_DELETE_MUTATION = `
+mutation CustomerAddressDelete($addressId: String!) {
+  customerAddressDelete(addressId: $addressId) {
+    deletedAddressId
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_UPDATE_MUTATION = `
+mutation CustomerUpdate($input: CustomerUpdateInput!) {
+  customerUpdate(input: $input) {
+    customer {
+      id
+      name
+      email
+      emailVerified
+    }
+    userErrors { field message code }
+  }
+}
+`;
+function mapOrderNode(data) {
+  return {
+    id: data.id,
+    orderNumber: data.orderNumber,
+    status: data.status,
+    email: data.customerEmail,
+    phone: data.customerPhone,
+    subtotal: data.subtotal,
+    total: data.total,
+    note: data.note,
+    items: data.items.map((item) => ({
+      id: item.id,
+      productTitle: item.productTitle,
+      variantTitle: item.variantTitle,
+      sku: item.sku,
+      quantity: item.quantity,
+      unitPrice: item.unitPrice,
+      totalPrice: item.totalPrice
+    })),
+    createdAt: data.createdAt
+  };
+}
+function mapAddressData(data) {
+  return {
+    id: data.id,
+    label: data.label,
+    firstName: data.firstName,
+    lastName: data.lastName,
+    addressLine1: data.addressLine1,
+    addressLine2: data.addressLine2,
+    city: data.city,
+    postalCode: data.postalCode,
+    phone: data.phone,
+    isDefault: data.isDefault,
+    createdAt: data.createdAt
+  };
+}
+function handleUserErrors$3(userErrors) {
+  if (userErrors.length === 0) return null;
+  const messages = userErrors.map((e) => e.message).join("; ");
+  return new errors.ValidationError(
+    messages,
+    userErrors.map((e) => ({ field: e.field, message: e.message }))
+  );
+}
+function createAccountOperations(client, storage) {
+  function requireAuth() {
+    if (!storage.get(CUSTOMER_TOKEN_KEY)) {
+      return neverthrow.err(new errors.AuthError("Not authenticated. Call auth.login() or auth.register() first."));
+    }
+    return neverthrow.ok(void 0);
+  }
+  return {
+    async orders(args) {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const variables = {};
+      if (args?.first !== void 0) variables.first = args.first;
+      if (args?.after !== void 0) variables.after = args.after;
+      if (args?.last !== void 0) variables.last = args.last;
+      if (args?.before !== void 0) variables.before = args.before;
+      if (!variables.first && !variables.last) variables.first = 20;
+      const result = await client.query(
+        { query: CUSTOMER_ORDERS_QUERY, variables },
+        { cache: false }
+      );
+      if (result.isErr()) return neverthrow.err(result.error);
+      const { edges, pageInfo } = result.value.customerOrders;
+      return neverthrow.ok({
+        items: edges.map((edge) => mapOrderNode(edge.node)),
+        pageInfo
+      });
+    },
+    async addresses() {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const result = await client.query(
+        { query: CUSTOMER_ADDRESSES_QUERY },
+        { cache: false }
+      );
+      if (result.isErr()) return neverthrow.err(result.error);
+      return neverthrow.ok(result.value.customerAddresses.map(mapAddressData));
+    },
+    async createAddress(input) {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const result = await client.mutate({
+        query: CUSTOMER_ADDRESS_CREATE_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerAddressCreate;
+      const userError = handleUserErrors$3(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.address) {
+        return neverthrow.err(new errors.ValidationError("Failed to create address", []));
+      }
+      return neverthrow.ok(mapAddressData(payload.address));
+    },
+    async updateAddress(addressId, input) {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const result = await client.mutate({
+        query: CUSTOMER_ADDRESS_UPDATE_MUTATION,
+        variables: { addressId, input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerAddressUpdate;
+      const userError = handleUserErrors$3(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.address) {
+        return neverthrow.err(new errors.ValidationError("Failed to update address", []));
+      }
+      return neverthrow.ok(mapAddressData(payload.address));
+    },
+    async deleteAddress(addressId) {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const result = await client.mutate({
+        query: CUSTOMER_ADDRESS_DELETE_MUTATION,
+        variables: { addressId }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerAddressDelete;
+      const userError = handleUserErrors$3(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.deletedAddressId) {
+        return neverthrow.err(new errors.ValidationError("Failed to delete address", []));
+      }
+      return neverthrow.ok(payload.deletedAddressId);
+    },
+    async update(input) {
+      const authCheck = requireAuth();
+      if (authCheck.isErr()) return neverthrow.err(authCheck.error);
+      const result = await client.mutate({
+        query: CUSTOMER_UPDATE_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerUpdate;
+      const userError = handleUserErrors$3(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.customer) {
+        return neverthrow.err(new errors.ValidationError("Failed to update profile", []));
+      }
+      return neverthrow.ok({
+        id: payload.customer.id,
+        name: payload.customer.name,
+        email: payload.customer.email,
+        emailVerified: payload.customer.emailVerified
+      });
+    }
+  };
+}
+const CUSTOMER_FRAGMENT = `
+  id
+  name
+  email
+  emailVerified
+`;
+const CUSTOMER_REGISTER_MUTATION = `
+mutation CustomerRegister($input: CustomerRegisterInput!) {
+  customerRegister(input: $input) {
+    customer { ${CUSTOMER_FRAGMENT} }
+    token
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_LOGIN_MUTATION = `
+mutation CustomerLogin($input: CustomerLoginInput!) {
+  customerLogin(input: $input) {
+    customer { ${CUSTOMER_FRAGMENT} }
+    token
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_PASSWORD_RESET_REQUEST_MUTATION = `
+mutation CustomerPasswordResetRequest($input: CustomerPasswordResetRequestInput!) {
+  customerPasswordResetRequest(input: $input) {
+    success
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_PASSWORD_RESET_MUTATION = `
+mutation CustomerPasswordReset($input: CustomerPasswordResetInput!) {
+  customerPasswordReset(input: $input) {
+    success
+    userErrors { field message code }
+  }
+}
+`;
+const CUSTOMER_VERIFY_EMAIL_MUTATION = `
+mutation CustomerVerifyEmail($input: CustomerVerifyEmailInput!) {
+  customerVerifyEmail(input: $input) {
+    customer { ${CUSTOMER_FRAGMENT} }
+    userErrors { field message code }
+  }
+}
+`;
+const ME_QUERY = `
+query Me {
+  me { ${CUSTOMER_FRAGMENT} }
+}
+`;
+function mapCustomerData(data) {
+  return {
+    id: data.id,
+    name: data.name,
+    email: data.email,
+    emailVerified: data.emailVerified
+  };
+}
+function handleUserErrors$2(userErrors) {
+  if (userErrors.length === 0) return null;
+  const messages = userErrors.map((e) => e.message).join("; ");
+  return new errors.ValidationError(
+    messages,
+    userErrors.map((e) => ({ field: e.field, message: e.message }))
+  );
+}
+function createAuthOperations(client, storage) {
+  return {
+    async register(input) {
+      const result = await client.mutate({
+        query: CUSTOMER_REGISTER_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerRegister;
+      const userError = handleUserErrors$2(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.customer || !payload.token) {
+        return neverthrow.err(new errors.ValidationError("Registration failed", []));
+      }
+      storage.set(CUSTOMER_TOKEN_KEY, payload.token);
+      return neverthrow.ok({ customer: mapCustomerData(payload.customer), token: payload.token });
+    },
+    async login(input) {
+      const result = await client.mutate({
+        query: CUSTOMER_LOGIN_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerLogin;
+      const userError = handleUserErrors$2(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.customer || !payload.token) {
+        return neverthrow.err(new errors.ValidationError("Login failed", []));
+      }
+      storage.set(CUSTOMER_TOKEN_KEY, payload.token);
+      return neverthrow.ok({ customer: mapCustomerData(payload.customer), token: payload.token });
+    },
+    logout() {
+      storage.remove(CUSTOMER_TOKEN_KEY);
+    },
+    async requestPasswordReset(email) {
+      const result = await client.mutate({
+        query: CUSTOMER_PASSWORD_RESET_REQUEST_MUTATION,
+        variables: { input: { email } }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerPasswordResetRequest;
+      const userError = handleUserErrors$2(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      return neverthrow.ok({ success: payload.success });
+    },
+    async resetPassword(input) {
+      const result = await client.mutate({
+        query: CUSTOMER_PASSWORD_RESET_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerPasswordReset;
+      const userError = handleUserErrors$2(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      return neverthrow.ok({ success: payload.success });
+    },
+    async verifyEmail(token) {
+      const result = await client.mutate({
+        query: CUSTOMER_VERIFY_EMAIL_MUTATION,
+        variables: { input: { token } }
+      });
+      if (result.isErr()) return neverthrow.err(result.error);
+      const payload = result.value.customerVerifyEmail;
+      const userError = handleUserErrors$2(payload.userErrors);
+      if (userError) return neverthrow.err(userError);
+      if (!payload.customer) {
+        return neverthrow.err(new errors.ValidationError("Email verification failed", []));
+      }
+      return neverthrow.ok(mapCustomerData(payload.customer));
+    },
+    async me() {
+      if (!storage.get(CUSTOMER_TOKEN_KEY)) return neverthrow.ok(null);
+      const result = await client.query({ query: ME_QUERY }, { cache: false });
+      if (result.isErr()) return neverthrow.err(result.error);
+      return neverthrow.ok(result.value.me ? mapCustomerData(result.value.me) : null);
+    },
+    isLoggedIn() {
+      return storage.get(CUSTOMER_TOKEN_KEY) !== null;
+    }
+  };
+}
+const TRACKING_SCHEMA_VERSION$1 = 1;
+const TRACKING_ATTRIBUTION_STORAGE_KEY = "srb_tracking_attribution";
+function hasBrowserContext$1() {
+  return typeof window !== "undefined";
+}
+function normalizeParam(value) {
+  if (value === null) return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function hasAttributionValue(snapshot) {
+  return [
+    snapshot.utm.source,
+    snapshot.utm.medium,
+    snapshot.utm.campaign,
+    snapshot.utm.term,
+    snapshot.utm.content,
+    snapshot.clickIds.gclid,
+    snapshot.clickIds.gbraid,
+    snapshot.clickIds.wbraid,
+    snapshot.clickIds.ttclid,
+    snapshot.clickIds.fbclid
+  ].some((value) => value !== null);
+}
+function parseStoredSnapshot(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== TRACKING_SCHEMA_VERSION$1 || typeof parsed.capturedAt !== "string") {
+      return null;
+    }
+    const utm = parsed.utm;
+    const clickIds = parsed.clickIds;
+    if (!utm || !clickIds) return null;
+    return {
+      schemaVersion: TRACKING_SCHEMA_VERSION$1,
+      capturedAt: parsed.capturedAt,
+      utm: {
+        schemaVersion: TRACKING_SCHEMA_VERSION$1,
+        source: typeof utm.source === "string" ? utm.source : null,
+        medium: typeof utm.medium === "string" ? utm.medium : null,
+        campaign: typeof utm.campaign === "string" ? utm.campaign : null,
+        term: typeof utm.term === "string" ? utm.term : null,
+        content: typeof utm.content === "string" ? utm.content : null
+      },
+      clickIds: {
+        schemaVersion: TRACKING_SCHEMA_VERSION$1,
+        capturedAt: typeof clickIds.capturedAt === "string" ? clickIds.capturedAt : null,
+        gclid: typeof clickIds.gclid === "string" ? clickIds.gclid : null,
+        gbraid: typeof clickIds.gbraid === "string" ? clickIds.gbraid : null,
+        wbraid: typeof clickIds.wbraid === "string" ? clickIds.wbraid : null,
+        ttclid: typeof clickIds.ttclid === "string" ? clickIds.ttclid : null,
+        fbclid: typeof clickIds.fbclid === "string" ? clickIds.fbclid : null
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function readStoredSnapshot() {
+  if (!hasBrowserContext$1()) return null;
+  try {
+    return parseStoredSnapshot(window.localStorage.getItem(TRACKING_ATTRIBUTION_STORAGE_KEY));
+  } catch {
+    return null;
+  }
+}
+function writeStoredSnapshot(snapshot) {
+  if (!hasBrowserContext$1()) return;
+  try {
+    window.localStorage.setItem(TRACKING_ATTRIBUTION_STORAGE_KEY, JSON.stringify(snapshot));
+  } catch {
+  }
+}
+function buildSnapshotFromSearch(search) {
+  const params = new URLSearchParams(search);
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: TRACKING_SCHEMA_VERSION$1,
+    capturedAt,
+    utm: {
+      schemaVersion: TRACKING_SCHEMA_VERSION$1,
+      source: normalizeParam(params.get("utm_source")),
+      medium: normalizeParam(params.get("utm_medium")),
+      campaign: normalizeParam(params.get("utm_campaign")),
+      term: normalizeParam(params.get("utm_term")),
+      content: normalizeParam(params.get("utm_content"))
+    },
+    clickIds: {
+      schemaVersion: TRACKING_SCHEMA_VERSION$1,
+      capturedAt,
+      gclid: normalizeParam(params.get("gclid")),
+      gbraid: normalizeParam(params.get("gbraid")),
+      wbraid: normalizeParam(params.get("wbraid")),
+      ttclid: normalizeParam(params.get("ttclid")),
+      fbclid: normalizeParam(params.get("fbclid"))
+    }
+  };
+}
+function captureLandingTrackingAttribution() {
+  if (!hasBrowserContext$1()) return null;
+  const snapshot = buildSnapshotFromSearch(window.location.search);
+  if (hasAttributionValue(snapshot)) {
+    writeStoredSnapshot(snapshot);
+    return snapshot;
+  }
+  return readStoredSnapshot();
+}
+function getTrackingAttributionSnapshot() {
+  return readStoredSnapshot();
+}
+function isAbsoluteUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function toOrigin(endpoint) {
+  try {
+    return new URL(endpoint).origin;
+  } catch {
+    return null;
+  }
+}
+function resolveAssetUrl(url, endpoint) {
+  if (!url) {
+    return url;
+  }
+  if (isAbsoluteUrl(url)) {
+    return url;
+  }
+  const origin = toOrigin(endpoint);
+  if (!origin) {
+    return url;
+  }
+  try {
+    return new URL(url, origin).toString();
+  } catch {
+    return url;
+  }
+}
+function normalizeProductAssetUrls(product, endpoint) {
+  return {
+    ...product,
+    media: product.media.map((media) => ({
+      ...media,
+      url: resolveAssetUrl(media.url, endpoint)
+    })),
+    variants: product.variants.map((variant) => ({
+      ...variant,
+      image: variant.image ? {
+        ...variant.image,
+        url: resolveAssetUrl(variant.image.url, endpoint)
+      } : null
+    }))
+  };
+}
+function normalizeCollectionAssetUrls(collection, endpoint) {
+  return {
+    ...collection,
+    imageAsset: collection.imageAsset ? { ...collection.imageAsset, url: resolveAssetUrl(collection.imageAsset.url, endpoint) } : null
+  };
+}
+const CART_FRAGMENT$1 = `
+  id
+  token
+  status
+  items {
+    id
+    variantId
+    quantity
+    priceAtAdd
+    effectiveUnitPrice
+    lineTotal
+    taxAmount
+    variant {
+      id
+      title
+      sku
+      price
+      compareAtPrice
+      weight
+      weightUnit
+      requiresShipping
+      availableForSale
+      quantity
+      selectedOptions { id value position }
+      image {
+        id
+        url
+        altText
+        position
+      }
+      isOnSale
+      quantityPricing { minQuantity price }
+    }
+  }
+  totalItems
+  totalPrice
+  taxTotal
+  shippingTotal
+  total
+  discountTotal
+  appliedPromoCode {
+    code
+    discountType
+    discountAmount
+    description
+  }
+  appliedDiscounts {
+    promotionId
+    discountClass
+    discountType
+    discountAmount
+    description
+    isAutomatic
+  }
+  customerEmail
+  customerPhone
+  shippingAddress
+  billingAddress
+  paymentMethod
+  shippingRateId
+  notes
+  checkoutStartedAt
+  checkoutExpiresAt
+  createdAt
+  updatedAt
+`;
+const CART_QUERY = `
+query Cart {
+  cart {
+    ${CART_FRAGMENT$1}
+  }
+}
+`;
+const CART_CREATE_MUTATION = `
+mutation CartCreate {
+  cartCreate {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    token
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_ITEM_ADD_MUTATION = `
+mutation CartItemAdd($input: CartItemAddInput!) {
+  cartItemAdd(input: $input) {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_ITEM_UPDATE_MUTATION = `
+mutation CartItemUpdate($input: CartItemUpdateInput!) {
+  cartItemUpdate(input: $input) {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_ITEM_REMOVE_MUTATION = `
+mutation CartItemRemove($input: CartItemRemoveInput!) {
+  cartItemRemove(input: $input) {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_CLEAR_MUTATION = `
+mutation CartClear {
+  cartClear {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_PROMO_CODE_APPLY_MUTATION = `
+mutation CartPromoCodeApply($input: CartPromoCodeApplyInput!) {
+  cartPromoCodeApply(input: $input) {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CART_PROMO_CODE_REMOVE_MUTATION = `
+mutation CartPromoCodeRemove {
+  cartPromoCodeRemove {
+    cart {
+      ${CART_FRAGMENT$1}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const INVALID_CART_STATES = ["checkout", "converted", "abandoned", "expired"];
+function mapCartData$1(data, endpoint) {
+  return {
+    id: data.id,
+    token: data.token,
+    status: data.status,
+    items: data.items.map((item) => ({
+      id: item.id,
+      variantId: item.variantId,
+      quantity: item.quantity,
+      priceAtAdd: item.priceAtAdd,
+      effectiveUnitPrice: item.effectiveUnitPrice,
+      lineTotal: item.lineTotal,
+      taxAmount: item.taxAmount,
+      variant: item.variant ? {
+        ...item.variant,
+        image: item.variant.image ? { ...item.variant.image, url: resolveAssetUrl(item.variant.image.url, endpoint) } : null
+      } : null
+    })),
+    totalItems: data.totalItems,
+    totalPrice: data.totalPrice,
+    taxTotal: data.taxTotal,
+    shippingTotal: data.shippingTotal,
+    total: data.total,
+    discountTotal: data.discountTotal,
+    appliedPromoCode: data.appliedPromoCode,
+    appliedDiscounts: data.appliedDiscounts,
+    customerEmail: data.customerEmail,
+    customerPhone: data.customerPhone,
+    shippingAddress: data.shippingAddress,
+    billingAddress: data.billingAddress,
+    paymentMethod: data.paymentMethod,
+    shippingRateId: data.shippingRateId,
+    notes: data.notes,
+    checkoutStartedAt: data.checkoutStartedAt ?? null,
+    checkoutExpiresAt: data.checkoutExpiresAt ?? null,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt
+  };
+}
+function checkCartState(status) {
+  if (INVALID_CART_STATES.includes(status)) {
+    return neverthrow.err(
+      new errors.StateError(
+        `Cannot modify cart in '${status}' state. Cart operations are only allowed when cart is in 'active' state.`,
+        status
+      )
+    );
+  }
+  return neverthrow.ok(void 0);
+}
+function handleUserErrors$1(userErrors) {
+  if (userErrors.length === 0) return null;
+  const messages = userErrors.map((e) => e.message).join("; ");
+  const stateError = userErrors.find((e) => e.code?.includes("STATE") || e.message.includes("state"));
+  if (stateError) {
+    return new errors.StateError(messages, "unknown");
+  }
+  return new errors.ValidationError(
+    messages,
+    userErrors.map((e) => ({ field: e.field, message: e.message }))
+  );
+}
+function createCartOperations(client, storage) {
+  return {
+    async get() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.ok(null);
+      }
+      const result = await client.query({ query: CART_QUERY }, { cache: false });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.cart) {
+        storage.remove(CART_TOKEN_KEY);
+        return neverthrow.ok(null);
+      }
+      return neverthrow.ok(mapCartData$1(result.value.cart, client.config.endpoint));
+    },
+    async create() {
+      const result = await client.mutate({
+        query: CART_CREATE_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartCreate;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart || !payload.token) {
+        return neverthrow.err(new errors.NotFoundError("Failed to create cart"));
+      }
+      storage.set(CART_TOKEN_KEY, payload.token);
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async addItem(variantId, quantity) {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_ITEM_ADD_MUTATION,
+        variables: {
+          input: {
+            variantId,
+            quantity,
+            trackingAttribution: captureLandingTrackingAttribution() ?? void 0
+          }
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartItemAdd;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      const stateCheck = checkCartState(payload.cart.status);
+      if (stateCheck.isErr()) {
+        return neverthrow.err(stateCheck.error);
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async updateItem(variantId, quantity) {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_ITEM_UPDATE_MUTATION,
+        variables: {
+          input: {
+            variantId,
+            quantity,
+            trackingAttribution: captureLandingTrackingAttribution() ?? void 0
+          }
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartItemUpdate;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      const stateCheck = checkCartState(payload.cart.status);
+      if (stateCheck.isErr()) {
+        return neverthrow.err(stateCheck.error);
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async removeItem(variantId) {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_ITEM_REMOVE_MUTATION,
+        variables: {
+          input: {
+            variantId,
+            trackingAttribution: captureLandingTrackingAttribution() ?? void 0
+          }
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartItemRemove;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      const stateCheck = checkCartState(payload.cart.status);
+      if (stateCheck.isErr()) {
+        return neverthrow.err(stateCheck.error);
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async clear() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_CLEAR_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartClear;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      const stateCheck = checkCartState(payload.cart.status);
+      if (stateCheck.isErr()) {
+        return neverthrow.err(stateCheck.error);
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async applyPromoCode(code) {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_PROMO_CODE_APPLY_MUTATION,
+        variables: { input: { code } }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartPromoCodeApply;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    },
+    async removePromoCode() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CART_PROMO_CODE_REMOVE_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.cartPromoCodeRemove;
+      const userError = handleUserErrors$1(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      return neverthrow.ok(mapCartData$1(payload.cart, client.config.endpoint));
+    }
+  };
+}
+const CATEGORY_FIELDS = `
+  id
+  name
+  handle
+  description
+  metaTitle
+  metaDescription
+  imageAsset {
+    url
+    altText
+    width
+    height
+  }
+  productCount
+`;
+const CATEGORIES_TREE_QUERY = `
+query CategoriesTree {
+  storefrontCategories {
+    ${CATEGORY_FIELDS}
+    children {
+      ${CATEGORY_FIELDS}
+      children {
+        ${CATEGORY_FIELDS}
+        children {
+          ${CATEGORY_FIELDS}
+          children {
+            ${CATEGORY_FIELDS}
+          }
+        }
+      }
+    }
+  }
+}
+`;
+const CATEGORY_BY_ID_QUERY = `
+query CategoryById($id: ID!) {
+  storefrontCategory(id: $id) {
+    ${CATEGORY_FIELDS}
+    parent {
+      ${CATEGORY_FIELDS}
+    }
+    children {
+      ${CATEGORY_FIELDS}
+    }
+    ancestors {
+      ${CATEGORY_FIELDS}
+    }
+  }
+}
+`;
+const CATEGORY_BY_HANDLE_QUERY = `
+query CategoryByHandle($handle: String!) {
+  storefrontCategory(handle: $handle) {
+    ${CATEGORY_FIELDS}
+    parent {
+      ${CATEGORY_FIELDS}
+    }
+    children {
+      ${CATEGORY_FIELDS}
+    }
+    ancestors {
+      ${CATEGORY_FIELDS}
+    }
+  }
+}
+`;
+const CATEGORY_PRODUCTS_BY_ID_QUERY = `
+query CategoryProductsById($id: ID!, $first: Int, $after: String, $includeDescendants: Boolean) {
+  storefrontCategory(id: $id) {
+    id
+    products(first: $first, after: $after, includeDescendants: $includeDescendants) {
+      edges {
+        node {
+          id
+          handle
+          title
+          description
+          vendor
+          productType
+          metaTitle
+          metaDescription
+          publishedAt
+          createdAt
+          availableForSale
+          media {
+            id
+            url
+            altText
+            position
+          }
+          options {
+            id
+            name
+            position
+            values {
+              id
+              value
+              position
+            }
+          }
+          variants {
+            id
+            title
+            sku
+            price
+            compareAtPrice
+            weight
+            weightUnit
+            requiresShipping
+            availableForSale
+            quantity
+            selectedOptions {
+              id
+              value
+              position
+            }
+            image {
+              id
+              url
+              altText
+              position
+            }
+            isOnSale
+            quantityPricing {
+              minQuantity
+              price
+            }
+          }
+          categories {
+            id
+            name
+            handle
+            description
+          }
+          primaryCategory {
+            id
+            name
+            handle
+          }
+          tags {
+            id
+            name
+          }
+        }
+        cursor
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+    }
+  }
+}
+`;
+const CATEGORY_PRODUCTS_BY_HANDLE_QUERY = `
+query CategoryProductsByHandle($handle: String!, $first: Int, $after: String, $includeDescendants: Boolean) {
+  storefrontCategory(handle: $handle) {
+    id
+    products(first: $first, after: $after, includeDescendants: $includeDescendants) {
+      edges {
+        node {
+          id
+          handle
+          title
+          description
+          vendor
+          productType
+          metaTitle
+          metaDescription
+          publishedAt
+          createdAt
+          availableForSale
+          media {
+            id
+            url
+            altText
+            position
+          }
+          options {
+            id
+            name
+            position
+            values {
+              id
+              value
+              position
+            }
+          }
+          variants {
+            id
+            title
+            sku
+            price
+            compareAtPrice
+            weight
+            weightUnit
+            requiresShipping
+            availableForSale
+            quantity
+            selectedOptions {
+              id
+              value
+              position
+            }
+            image {
+              id
+              url
+              altText
+              position
+            }
+            isOnSale
+            quantityPricing {
+              minQuantity
+              price
+            }
+          }
+          categories {
+            id
+            name
+            handle
+            description
+          }
+          primaryCategory {
+            id
+            name
+            handle
+          }
+          tags {
+            id
+            name
+          }
+        }
+        cursor
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+    }
+  }
+}
+`;
+function mapRawCategory(raw, endpoint) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    handle: raw.handle,
+    description: raw.description,
+    metaTitle: raw.metaTitle,
+    metaDescription: raw.metaDescription,
+    imageAsset: raw.imageAsset ? {
+      url: resolveAssetUrl(raw.imageAsset.url, endpoint),
+      altText: raw.imageAsset.altText,
+      width: raw.imageAsset.width,
+      height: raw.imageAsset.height
+    } : null,
+    parent: raw.parent ? mapRawCategory(raw.parent, endpoint) : null,
+    children: raw.children?.map((child) => mapRawCategory(child, endpoint)) ?? [],
+    ancestors: raw.ancestors?.map((ancestor) => mapRawCategory(ancestor, endpoint)) ?? [],
+    productCount: raw.productCount
+  };
+}
+function flattenTree(categories, parentId, depth) {
+  const result = [];
+  for (const cat of categories) {
+    result.push({
+      id: cat.id,
+      name: cat.name,
+      handle: cat.handle,
+      description: cat.description,
+      metaTitle: cat.metaTitle,
+      metaDescription: cat.metaDescription,
+      imageUrl: cat.imageAsset?.url ?? null,
+      parentId,
+      depth,
+      hasChildren: cat.children.length > 0,
+      productCount: cat.productCount
+    });
+    result.push(...flattenTree(cat.children, cat.id, depth + 1));
+  }
+  return result;
+}
+function isGlobalId$2(value) {
+  if (!value.includes(":")) {
+    try {
+      const decoded = atob(value);
+      return decoded.includes(":");
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function createCategoriesOperations(client) {
+  return {
+    async tree() {
+      const result = await client.query({
+        query: CATEGORIES_TREE_QUERY
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      return neverthrow.ok(result.value.storefrontCategories.map((category) => mapRawCategory(category, client.config.endpoint)));
+    },
+    async flat() {
+      const result = await client.query({
+        query: CATEGORIES_TREE_QUERY
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const tree = result.value.storefrontCategories.map(
+        (category) => mapRawCategory(category, client.config.endpoint)
+      );
+      return neverthrow.ok(flattenTree(tree, null, 0));
+    },
+    async get(idOrHandle) {
+      const useId = isGlobalId$2(idOrHandle);
+      const result = await client.query({
+        query: useId ? CATEGORY_BY_ID_QUERY : CATEGORY_BY_HANDLE_QUERY,
+        variables: useId ? { id: idOrHandle } : { handle: idOrHandle }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.storefrontCategory) {
+        return neverthrow.err(new errors.NotFoundError(`Category not found: ${idOrHandle}`));
+      }
+      return neverthrow.ok(mapRawCategory(result.value.storefrontCategory, client.config.endpoint));
+    },
+    async getProducts(idOrHandle, options) {
+      const useId = isGlobalId$2(idOrHandle);
+      const result = await client.query({
+        query: useId ? CATEGORY_PRODUCTS_BY_ID_QUERY : CATEGORY_PRODUCTS_BY_HANDLE_QUERY,
+        variables: {
+          ...useId ? { id: idOrHandle } : { handle: idOrHandle },
+          first: options?.first,
+          after: options?.after,
+          ...options?.includeDescendants !== void 0 && { includeDescendants: options.includeDescendants }
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.storefrontCategory) {
+        return neverthrow.err(new errors.NotFoundError(`Category not found: ${idOrHandle}`));
+      }
+      const connection = result.value.storefrontCategory.products;
+      return neverthrow.ok({
+        items: connection.edges.map((edge) => normalizeProductAssetUrls(edge.node, client.config.endpoint)),
+        pageInfo: {
+          hasNextPage: connection.pageInfo.hasNextPage,
+          hasPreviousPage: connection.pageInfo.hasPreviousPage,
+          startCursor: connection.pageInfo.startCursor,
+          endCursor: connection.pageInfo.endCursor
+        }
+      });
+    }
+  };
+}
+const CART_FRAGMENT = `
+  id
+  token
+  status
+  items {
+    id
+    variantId
+    quantity
+    priceAtAdd
+    effectiveUnitPrice
+    lineTotal
+    taxAmount
+    variant {
+      id
+      title
+      sku
+      price
+      compareAtPrice
+      weight
+      weightUnit
+      requiresShipping
+      availableForSale
+      quantity
+      selectedOptions { id value position }
+      image {
+        id
+        url
+        altText
+        position
+      }
+      isOnSale
+      quantityPricing { minQuantity price }
+    }
+  }
+  totalItems
+  totalPrice
+  taxTotal
+  shippingTotal
+  total
+  discountTotal
+  appliedPromoCode {
+    code
+    discountType
+    discountAmount
+    description
+  }
+  appliedDiscounts {
+    promotionId
+    discountClass
+    discountType
+    discountAmount
+    description
+    isAutomatic
+  }
+  customerEmail
+  customerPhone
+  shippingAddress
+  billingAddress
+  paymentMethod
+  shippingRateId
+  notes
+  checkoutStartedAt
+  checkoutExpiresAt
+  createdAt
+  updatedAt
+`;
+const CHECKOUT_START_MUTATION = `
+mutation CheckoutStart {
+  checkoutStart {
+    cart {
+      ${CART_FRAGMENT}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CHECKOUT_UPDATE_MUTATION = `
+mutation CheckoutUpdate($input: CheckoutUpdateInput!) {
+  checkoutUpdate(input: $input) {
+    cart {
+      ${CART_FRAGMENT}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CHECKOUT_CONVERT_MUTATION = `
+mutation CheckoutConvert {
+  checkoutConvert {
+    order {
+      id
+      orderNumber
+      status
+      customerEmail
+      customerPhone
+      shippingAddress
+      billingAddress
+      subtotal
+      total
+      note
+      items {
+        id
+        productTitle
+        variantTitle
+        sku
+        quantity
+        unitPrice
+        totalPrice
+      }
+      createdAt
+    }
+    paymentInstructions {
+      bankAccount
+      recipientName
+      referenceNumber
+      ipsQrCodeBase64
+      expiresAt
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+const CHECKOUT_ABANDON_MUTATION = `
+mutation CheckoutAbandon {
+  checkoutAbandon {
+    cart {
+      ${CART_FRAGMENT}
+    }
+    userErrors {
+      field
+      message
+      code
+    }
+  }
+}
+`;
+function mapCartData(data, endpoint) {
+  return {
+    id: data.id,
+    token: data.token,
+    status: data.status,
+    items: data.items.map((item) => ({
+      id: item.id,
+      variantId: item.variantId,
+      quantity: item.quantity,
+      priceAtAdd: item.priceAtAdd,
+      effectiveUnitPrice: item.effectiveUnitPrice,
+      lineTotal: item.lineTotal,
+      taxAmount: item.taxAmount,
+      variant: item.variant ? {
+        ...item.variant,
+        image: item.variant.image ? { ...item.variant.image, url: resolveAssetUrl(item.variant.image.url, endpoint) } : null
+      } : null
+    })),
+    totalItems: data.totalItems,
+    totalPrice: data.totalPrice,
+    taxTotal: data.taxTotal,
+    shippingTotal: data.shippingTotal,
+    total: data.total,
+    discountTotal: data.discountTotal,
+    appliedPromoCode: data.appliedPromoCode,
+    appliedDiscounts: data.appliedDiscounts,
+    customerEmail: data.customerEmail,
+    customerPhone: data.customerPhone,
+    shippingAddress: data.shippingAddress,
+    billingAddress: data.billingAddress,
+    paymentMethod: data.paymentMethod,
+    shippingRateId: data.shippingRateId,
+    notes: data.notes,
+    checkoutStartedAt: data.checkoutStartedAt ?? null,
+    checkoutExpiresAt: data.checkoutExpiresAt ?? null,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt
+  };
+}
+function mapOrderData(data, paymentInstructions) {
+  return {
+    id: data.id,
+    orderNumber: data.orderNumber,
+    email: data.customerEmail,
+    phone: data.customerPhone,
+    status: data.status,
+    shippingAddress: data.shippingAddress,
+    subtotal: data.subtotal,
+    total: data.total,
+    note: data.note,
+    items: data.items.map((item) => ({
+      id: item.id,
+      productTitle: item.productTitle,
+      variantTitle: item.variantTitle,
+      sku: item.sku,
+      quantity: item.quantity,
+      unitPrice: item.unitPrice,
+      totalPrice: item.totalPrice
+    })),
+    paymentInstructions: paymentInstructions ?? null,
+    createdAt: data.createdAt
+  };
+}
+function handleUserErrors(userErrors) {
+  if (userErrors.length === 0) return null;
+  const messages = userErrors.map((e) => e.message).join("; ");
+  const stateErrorCodes = ["CART_NOT_IN_CHECKOUT", "CHECKOUT_START_ERROR", "CHECKOUT_ABANDON_ERROR"];
+  const stateError = userErrors.find(
+    (e) => e.code?.includes("STATE") || e.message.includes("state") || e.code && stateErrorCodes.includes(e.code)
+  );
+  if (stateError) {
+    return new errors.StateError(messages, "unknown");
+  }
+  return new errors.ValidationError(
+    messages,
+    userErrors.map((e) => ({ field: e.field, message: e.message }))
+  );
+}
+function checkCartIsInCheckout(status) {
+  if (status !== "checkout") {
+    return neverthrow.err(
+      new errors.StateError(`Cart must be in 'checkout' state for this operation. Current state: '${status}'.`, status)
+    );
+  }
+  return neverthrow.ok(void 0);
+}
+function createCheckoutOperations(client, storage) {
+  return {
+    async start() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CHECKOUT_START_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.checkoutStart;
+      const userError = handleUserErrors(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      return neverthrow.ok(mapCartData(payload.cart, client.config.endpoint));
+    },
+    async update(data) {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const input = {};
+      if (data.email !== void 0) input.customerEmail = data.email;
+      if (data.phone !== void 0) input.customerPhone = data.phone;
+      if (data.shippingAddress !== void 0) input.shippingAddress = data.shippingAddress;
+      if (data.billingAddress !== void 0) input.billingAddress = data.billingAddress;
+      if (data.notes !== void 0) input.notes = data.notes;
+      if (data.emailMarketingConsent !== void 0) input.emailMarketingConsent = data.emailMarketingConsent;
+      if (data.paymentMethod !== void 0) input.paymentMethod = data.paymentMethod;
+      if (data.shippingRateId !== void 0) input.shippingRateId = data.shippingRateId;
+      const result = await client.mutate({
+        query: CHECKOUT_UPDATE_MUTATION,
+        variables: { input }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.checkoutUpdate;
+      const userError = handleUserErrors(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      const stateCheck = checkCartIsInCheckout(payload.cart.status);
+      if (stateCheck.isErr()) {
+        return neverthrow.err(stateCheck.error);
+      }
+      return neverthrow.ok(mapCartData(payload.cart, client.config.endpoint));
+    },
+    async complete() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CHECKOUT_CONVERT_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.checkoutConvert;
+      const userError = handleUserErrors(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.order) {
+        return neverthrow.err(new errors.NotFoundError("Order not found"));
+      }
+      storage.remove(CART_TOKEN_KEY);
+      return neverthrow.ok(mapOrderData(payload.order, payload.paymentInstructions));
+    },
+    async abandon() {
+      const token = storage.get(CART_TOKEN_KEY);
+      if (!token) {
+        return neverthrow.err(new errors.NotFoundError("No cart exists. Call cart.create() first."));
+      }
+      const result = await client.mutate({
+        query: CHECKOUT_ABANDON_MUTATION
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const payload = result.value.checkoutAbandon;
+      const userError = handleUserErrors(payload.userErrors);
+      if (userError) {
+        return neverthrow.err(userError);
+      }
+      if (!payload.cart) {
+        return neverthrow.err(new errors.NotFoundError("Cart not found"));
+      }
+      return neverthrow.ok(mapCartData(payload.cart, client.config.endpoint));
+    }
+  };
+}
+function mapRawCollection(raw, endpoint) {
+  return {
+    id: raw.id,
+    handle: raw.handle,
+    title: raw.title,
+    description: raw.description,
+    type: raw.type,
+    sortOrder: raw.sortOrder,
+    metaTitle: raw.metaTitle,
+    metaDescription: raw.metaDescription,
+    productCount: raw.productCount,
+    imageAsset: raw.imageAsset ? {
+      url: resolveAssetUrl(raw.imageAsset.url, endpoint),
+      altText: raw.imageAsset.altText,
+      width: raw.imageAsset.width,
+      height: raw.imageAsset.height
+    } : null
+  };
+}
+const COLLECTIONS_QUERY = `
+query Collections($first: Int, $after: String, $search: String) {
+  collections(first: $first, after: $after, search: $search) {
+    edges {
+      node {
+        id
+        handle
+        title
+        description
+        type
+        sortOrder
+        metaTitle
+        metaDescription
+        productCount
+        imageAsset {
+          url
+          altText
+          width
+          height
+        }
+      }
+      cursor
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+  }
+}
+`;
+const COLLECTION_BY_ID_QUERY = `
+query CollectionById($id: ID!) {
+  collection(id: $id) {
+    id
+    handle
+    title
+    description
+    type
+    sortOrder
+    metaTitle
+    metaDescription
+    productCount
+    imageAsset {
+      url
+      altText
+      width
+      height
+    }
+  }
+}
+`;
+const COLLECTION_BY_HANDLE_QUERY = `
+query CollectionByHandle($handle: String!) {
+  collection(handle: $handle) {
+    id
+    handle
+    title
+    description
+    type
+    sortOrder
+    metaTitle
+    metaDescription
+    productCount
+    imageAsset {
+      url
+      altText
+      width
+      height
+    }
+  }
+}
+`;
+const COLLECTION_PRODUCTS_BY_ID_QUERY = `
+query CollectionProductsById($id: ID!, $first: Int, $after: String, $sort: CollectionSortOrder) {
+  collection(id: $id) {
+    id
+    products(first: $first, after: $after, sort: $sort) {
+      edges {
+        node {
+          id
+          handle
+          title
+          description
+          vendor
+          productType
+          metaTitle
+          metaDescription
+          publishedAt
+          createdAt
+          availableForSale
+          media {
+            id
+            url
+            altText
+            position
+          }
+          options {
+            id
+            name
+            position
+            values {
+              id
+              value
+              position
+            }
+          }
+          variants {
+            id
+            title
+            sku
+            price
+            compareAtPrice
+            weight
+            weightUnit
+            requiresShipping
+            availableForSale
+            quantity
+            selectedOptions {
+              id
+              value
+              position
+            }
+            image {
+              id
+              url
+              altText
+              position
+            }
+          }
+          categories {
+            id
+            name
+            handle
+            description
+          }
+          primaryCategory {
+            id
+            name
+            handle
+          }
+          tags {
+            id
+            name
+          }
+        }
+        cursor
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+    }
+  }
+}
+`;
+const COLLECTION_PRODUCTS_BY_HANDLE_QUERY = `
+query CollectionProductsByHandle($handle: String!, $first: Int, $after: String, $sort: CollectionSortOrder) {
+  collection(handle: $handle) {
+    id
+    products(first: $first, after: $after, sort: $sort) {
+      edges {
+        node {
+          id
+          handle
+          title
+          description
+          vendor
+          productType
+          metaTitle
+          metaDescription
+          publishedAt
+          createdAt
+          availableForSale
+          media {
+            id
+            url
+            altText
+            position
+          }
+          options {
+            id
+            name
+            position
+            values {
+              id
+              value
+              position
+            }
+          }
+          variants {
+            id
+            title
+            sku
+            price
+            compareAtPrice
+            weight
+            weightUnit
+            requiresShipping
+            availableForSale
+            quantity
+            selectedOptions {
+              id
+              value
+              position
+            }
+            image {
+              id
+              url
+              altText
+              position
+            }
+          }
+          categories {
+            id
+            name
+            handle
+            description
+          }
+          primaryCategory {
+            id
+            name
+            handle
+          }
+          tags {
+            id
+            name
+          }
+        }
+        cursor
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+    }
+  }
+}
+`;
+function isGlobalId$1(value) {
+  if (!value.includes(":")) {
+    try {
+      const decoded = atob(value);
+      return decoded.includes(":");
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function createCollectionsOperations(client) {
+  return {
+    async list(options) {
+      const result = await client.query({
+        query: COLLECTIONS_QUERY,
+        variables: {
+          first: options?.first,
+          after: options?.after,
+          search: options?.search
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const connection = result.value.collections;
+      return neverthrow.ok({
+        items: connection.edges.map((edge) => mapRawCollection(edge.node, client.config.endpoint)),
+        pageInfo: {
+          hasNextPage: connection.pageInfo.hasNextPage,
+          hasPreviousPage: connection.pageInfo.hasPreviousPage,
+          startCursor: connection.pageInfo.startCursor,
+          endCursor: connection.pageInfo.endCursor
+        }
+      });
+    },
+    async get(idOrHandle) {
+      const useId = isGlobalId$1(idOrHandle);
+      const result = await client.query({
+        query: useId ? COLLECTION_BY_ID_QUERY : COLLECTION_BY_HANDLE_QUERY,
+        variables: useId ? { id: idOrHandle } : { handle: idOrHandle }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.collection) {
+        return neverthrow.err(new errors.NotFoundError(`Collection not found: ${idOrHandle}`));
+      }
+      const collection = mapRawCollection(result.value.collection, client.config.endpoint);
+      return neverthrow.ok(normalizeCollectionAssetUrls(collection, client.config.endpoint));
+    },
+    async getProducts(idOrHandle, options) {
+      const useId = isGlobalId$1(idOrHandle);
+      const result = await client.query({
+        query: useId ? COLLECTION_PRODUCTS_BY_ID_QUERY : COLLECTION_PRODUCTS_BY_HANDLE_QUERY,
+        variables: {
+          ...useId ? { id: idOrHandle } : { handle: idOrHandle },
+          first: options?.first,
+          after: options?.after,
+          ...options?.sort !== void 0 && { sort: options.sort }
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.collection) {
+        return neverthrow.err(new errors.NotFoundError(`Collection not found: ${idOrHandle}`));
+      }
+      const connection = result.value.collection.products;
+      return neverthrow.ok({
+        items: connection.edges.map((edge) => normalizeProductAssetUrls(edge.node, client.config.endpoint)),
+        pageInfo: {
+          hasNextPage: connection.pageInfo.hasNextPage,
+          hasPreviousPage: connection.pageInfo.hasPreviousPage,
+          startCursor: connection.pageInfo.startCursor,
+          endCursor: connection.pageInfo.endCursor
+        }
+      });
+    }
+  };
+}
+function mapHttpError(status, body) {
+  if (status === 401 || status === 403) {
+    let message = "Authentication failed";
+    try {
+      const parsed = JSON.parse(body);
+      message = parsed.error ?? parsed.message ?? message;
+    } catch {
+    }
+    return new errors.AuthError(message);
+  }
+  if (status === 404) {
+    return new errors.NotFoundError("Resource not found");
+  }
+  return new errors.GraphQLError(`HTTP error ${status}`, [{ message: body }]);
+}
+function mapGraphQLErrors(errors$1) {
+  const messages = errors$1.map((e) => e.message).join("; ");
+  return new errors.GraphQLError(messages, errors$1);
+}
+function getCacheKey(request) {
+  return JSON.stringify({
+    query: request.query,
+    variables: request.variables ?? {},
+    operationName: request.operationName
+  });
+}
+function createGraphQLClient(config) {
+  async function execute(request) {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-storefront-key": config.apiKey
+    };
+    const cartToken = config.getCartToken();
+    if (cartToken) {
+      headers["x-cart-token"] = cartToken;
+    }
+    const customerToken = config.getCustomerToken();
+    if (customerToken) {
+      headers["Authorization"] = `Bearer ${customerToken}`;
+    }
+    let response;
+    try {
+      response = await fetch(config.endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          query: request.query,
+          variables: request.variables,
+          operationName: request.operationName
+        })
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Network request failed";
+      return neverthrow.err(new errors.NetworkError(message, { cause: error instanceof Error ? error : void 0 }));
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return neverthrow.err(mapHttpError(response.status, body));
+    }
+    let json;
+    try {
+      json = await response.json();
+    } catch {
+      return neverthrow.err(new errors.GraphQLError("Invalid JSON response", [{ message: "Failed to parse response" }]));
+    }
+    return neverthrow.ok(json);
+  }
+  return {
+    async query(request, options) {
+      const useCache = options?.cache !== false;
+      const cacheKey = getCacheKey(request);
+      if (useCache) {
+        const cached = config.cache.get(cacheKey);
+        if (cached !== null) {
+          return neverthrow.ok(cached);
+        }
+      }
+      const result = await execute(request);
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const response = result.value;
+      if (response.errors && response.errors.length > 0) {
+        return neverthrow.err(mapGraphQLErrors(response.errors));
+      }
+      if (!response.data) {
+        return neverthrow.err(new errors.GraphQLError("No data in response", [{ message: "Response has no data" }]));
+      }
+      if (useCache) {
+        config.cache.set(cacheKey, response.data, config.cacheTTL);
+      }
+      return neverthrow.ok(response.data);
+    },
+    async mutate(request) {
+      const result = await execute(request);
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const response = result.value;
+      if (response.errors && response.errors.length > 0) {
+        return neverthrow.err(mapGraphQLErrors(response.errors));
+      }
+      if (!response.data) {
+        return neverthrow.err(new errors.GraphQLError("No data in response", [{ message: "Response has no data" }]));
+      }
+      return neverthrow.ok(response.data);
+    }
+  };
+}
+function extractUserErrors(data, fieldName) {
+  const payload = data[fieldName];
+  if (!payload || typeof payload !== "object") {
+    return neverthrow.err(new errors.ValidationError("Unexpected response format", []));
+  }
+  const typedPayload = payload;
+  if (typedPayload.userErrors && typedPayload.userErrors.length > 0) {
+    const messages = typedPayload.userErrors.map((e) => e.message).join("; ");
+    return neverthrow.err(new errors.ValidationError(messages, typedPayload.userErrors));
+  }
+  return neverthrow.ok(payload);
+}
+const AVAILABLE_PAYMENT_METHODS_QUERY = `
+query AvailablePaymentMethods {
+  availablePaymentMethods {
+    method
+    displayName
+    additionalFee
+  }
+}
+`;
+function mapPaymentMethod(data) {
+  return {
+    method: data.method,
+    displayName: data.displayName,
+    additionalFee: data.additionalFee
+  };
+}
+function createPaymentsOperations(client) {
+  return {
+    async getAvailableMethods() {
+      const result = await client.query(
+        { query: AVAILABLE_PAYMENT_METHODS_QUERY },
+        { cache: true }
+      );
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.availablePaymentMethods) {
+        return neverthrow.err(new errors.NotFoundError("Payment methods not available"));
+      }
+      return neverthrow.ok(result.value.availablePaymentMethods.map(mapPaymentMethod));
+    }
+  };
+}
+const PRODUCTS_QUERY = `
+query Products($first: Int, $after: String, $filter: ProductFilter, $sort: ProductSortKey) {
+  products(first: $first, after: $after, filter: $filter, sort: $sort) {
+    edges {
+      node {
+        id
+        handle
+        title
+        description
+        vendor
+        productType
+        metaTitle
+        metaDescription
+        publishedAt
+        createdAt
+        availableForSale
+        media {
+          id
+          url
+          altText
+          position
+        }
+        options {
+          id
+          name
+          position
+          values {
+            id
+            value
+            position
+          }
+        }
+        variants {
+          id
+          title
+          sku
+          price
+          compareAtPrice
+          weight
+          weightUnit
+          requiresShipping
+          availableForSale
+          quantity
+          selectedOptions {
+            id
+            value
+            position
+          }
+          image {
+            id
+            url
+            altText
+            position
+          }
+          isOnSale
+          quantityPricing {
+            minQuantity
+            price
+          }
+        }
+        categories {
+          id
+          name
+          handle
+          description
+        }
+        primaryCategory {
+          id
+          name
+          handle
+        }
+        tags {
+          id
+          name
+        }
+      }
+      cursor
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+  }
+}
+`;
+const PRODUCT_BY_ID_QUERY = `
+query ProductById($id: ID!) {
+  product(id: $id) {
+    id
+    handle
+    title
+    description
+    vendor
+    productType
+    metaTitle
+    metaDescription
+    publishedAt
+    createdAt
+    availableForSale
+    media {
+      id
+      url
+      altText
+      position
+    }
+    options {
+      id
+      name
+      position
+      values {
+        id
+        value
+        position
+      }
+    }
+    variants {
+      id
+      title
+      sku
+      price
+      compareAtPrice
+      weight
+      weightUnit
+      requiresShipping
+      availableForSale
+      quantity
+      selectedOptions {
+        id
+        value
+        position
+      }
+      image {
+        id
+        url
+        altText
+        position
+      }
+      isOnSale
+      quantityPricing {
+        minQuantity
+        price
+      }
+    }
+    categories {
+      id
+      name
+      handle
+      description
+    }
+    tags {
+      id
+      name
+    }
+  }
+}
+`;
+const PRODUCT_BY_HANDLE_QUERY = `
+query ProductByHandle($handle: String!) {
+  product(handle: $handle) {
+    id
+    handle
+    title
+    description
+    vendor
+    productType
+    metaTitle
+    metaDescription
+    publishedAt
+    createdAt
+    availableForSale
+    media {
+      id
+      url
+      altText
+      position
+    }
+    options {
+      id
+      name
+      position
+      values {
+        id
+        value
+        position
+      }
+    }
+    variants {
+      id
+      title
+      sku
+      price
+      compareAtPrice
+      weight
+      weightUnit
+      requiresShipping
+      availableForSale
+      quantity
+      selectedOptions {
+        id
+        value
+        position
+      }
+      image {
+        id
+        url
+        altText
+        position
+      }
+      isOnSale
+      quantityPricing {
+        minQuantity
+        price
+      }
+    }
+    categories {
+      id
+      name
+      handle
+      description
+    }
+    tags {
+      id
+      name
+    }
+  }
+}
+`;
+const PRODUCTS_BY_HANDLES_QUERY = `
+query ProductsByHandles($handles: [String!]!) {
+  productsByHandles(handles: $handles) {
+    id
+    handle
+    title
+    description
+    vendor
+    productType
+    metaTitle
+    metaDescription
+    publishedAt
+    createdAt
+    availableForSale
+    media {
+      id
+      url
+      altText
+      position
+    }
+    options {
+      id
+      name
+      position
+      values {
+        id
+        value
+        position
+      }
+    }
+    variants {
+      id
+      title
+      sku
+      price
+      compareAtPrice
+      weight
+      weightUnit
+      requiresShipping
+      availableForSale
+      quantity
+      selectedOptions {
+        id
+        value
+        position
+      }
+      image {
+        id
+        url
+        altText
+        position
+      }
+      isOnSale
+      quantityPricing {
+        minQuantity
+        price
+      }
+    }
+    categories {
+      id
+      name
+      handle
+      description
+    }
+    tags {
+      id
+      name
+    }
+  }
+}
+`;
+function isGlobalId(value) {
+  if (!value.includes(":")) {
+    try {
+      const decoded = atob(value);
+      return decoded.includes(":");
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function createProductsOperations(client) {
+  return {
+    async list(options) {
+      const result = await client.query({
+        query: PRODUCTS_QUERY,
+        variables: {
+          first: options?.first,
+          after: options?.after,
+          filter: options?.filter,
+          sort: options?.sort
+        }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      const connection = result.value.products;
+      return neverthrow.ok({
+        items: connection.edges.map((edge) => normalizeProductAssetUrls(edge.node, client.config.endpoint)),
+        pageInfo: {
+          hasNextPage: connection.pageInfo.hasNextPage,
+          hasPreviousPage: connection.pageInfo.hasPreviousPage,
+          startCursor: connection.pageInfo.startCursor,
+          endCursor: connection.pageInfo.endCursor
+        }
+      });
+    },
+    async get(idOrHandle) {
+      const useId = isGlobalId(idOrHandle);
+      const result = await client.query({
+        query: useId ? PRODUCT_BY_ID_QUERY : PRODUCT_BY_HANDLE_QUERY,
+        variables: useId ? { id: idOrHandle } : { handle: idOrHandle }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.product) {
+        return neverthrow.err(new errors.NotFoundError(`Product not found: ${idOrHandle}`));
+      }
+      return neverthrow.ok(normalizeProductAssetUrls(result.value.product, client.config.endpoint));
+    },
+    async getByHandles(handles) {
+      if (handles.length === 0) {
+        return neverthrow.ok([]);
+      }
+      const result = await client.query({
+        query: PRODUCTS_BY_HANDLES_QUERY,
+        variables: { handles }
+      });
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      return neverthrow.ok(
+        result.value.productsByHandles.map(
+          (product) => product ? normalizeProductAssetUrls(product, client.config.endpoint) : null
+        )
+      );
+    }
+  };
+}
+const ANALYTICS_PATH = "/analytics/ingest";
+const VISITOR_COOKIE_NAME = "srb_vid";
+const SESSION_STORAGE_KEY = "srb_sid";
+const SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+const TRACKING_SCHEMA_VERSION = 1;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ANALYTICS_PRESET_EVENT_MAP = {
+  page_view: "analytics.page_view",
+  product_view: "analytics.product_view",
+  collection_view: "analytics.collection_view",
+  search_performed: "analytics.search_performed",
+  add_to_cart: "analytics.add_to_cart",
+  remove_from_cart: "analytics.remove_from_cart",
+  checkout_started: "analytics.checkout_started",
+  checkout_step_completed: "analytics.checkout_step_completed",
+  checkout_completed: "analytics.checkout_completed"
+};
+function hasBrowserContext() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function getDocument() {
+  return hasBrowserContext() ? document : null;
+}
+function getWindow() {
+  return hasBrowserContext() ? window : null;
+}
+function isUuid(value) {
+  return UUID_REGEX.test(value);
+}
+function randomUuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  return template.replace(/[xy]/g, (character) => {
+    const random = Math.floor(Math.random() * 16);
+    const value = character === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
+function getOrCreateVisitorId() {
+  const doc = getDocument();
+  if (doc) {
+    const raw = doc.cookie;
+    for (const pair of raw.split(";")) {
+      const [name, ...valueParts] = pair.trim().split("=");
+      if (name === VISITOR_COOKIE_NAME) {
+        return valueParts.join("=") ? decodeURIComponent(valueParts.join("=")) : randomUuid();
+      }
+    }
+  }
+  const value = randomUuid();
+  if (doc) {
+    const maxAge = 60 * 60 * 24 * 365 * 2;
+    doc.cookie = `${VISITOR_COOKIE_NAME}=${encodeURIComponent(value)}; Max-Age=${maxAge}; Path=/; SameSite=Lax`;
+  }
+  return value;
+}
+let fallbackSessionState = null;
+function getSessionStorageState() {
+  const win = getWindow();
+  if (!win) return fallbackSessionState;
+  try {
+    const raw = win.localStorage.getItem(SESSION_STORAGE_KEY);
+    if (!raw) return fallbackSessionState;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const id = parsed.id;
+    const startedAt = parsed.startedAt;
+    const lastSeenAt = parsed.lastSeenAt;
+    if (typeof id !== "string" || !id) return null;
+    if (typeof startedAt !== "number" || typeof lastSeenAt !== "number") return null;
+    return { id, startedAt, lastSeenAt };
+  } catch {
+    return fallbackSessionState;
+  }
+}
+function setSessionStorageState(state) {
+  fallbackSessionState = state;
+  const win = getWindow();
+  if (!win) return;
+  try {
+    win.localStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(state));
+  } catch {
+  }
+}
+function resolveSessionState(existing, nowMs) {
+  if (!existing) {
+    return { id: randomUuid(), startedAt: nowMs, lastSeenAt: nowMs };
+  }
+  if (nowMs - existing.lastSeenAt > SESSION_TIMEOUT_MS) {
+    return { id: randomUuid(), startedAt: nowMs, lastSeenAt: nowMs };
+  }
+  return { id: existing.id, startedAt: existing.startedAt, lastSeenAt: nowMs };
+}
+function getSessionId(nowMs) {
+  const existing = getSessionStorageState();
+  const state = resolveSessionState(existing, nowMs);
+  setSessionStorageState(state);
+  return state.id;
+}
+function normalizeNumber(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+function toCents(amount) {
+  return Math.max(0, Math.round(normalizeNumber(amount) * 100));
+}
+function base64UrlDecode(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = normalized.length % 4;
+  const padded = padding === 0 ? normalized : normalized + "=".repeat(4 - padding);
+  return atob(padded);
+}
+function parseJWT(payload) {
+  try {
+    const decoded = base64UrlDecode(payload);
+    const parsed = JSON.parse(decoded);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseCustomerIdFromToken(token) {
+  if (!token) return null;
+  const payload = token.split(".");
+  const encodedPayload = payload[1];
+  if (!encodedPayload) return null;
+  const parsed = parseJWT(encodedPayload);
+  if (!parsed) return null;
+  const customerId = parsed.customerId;
+  return typeof customerId === "string" && isUuid(customerId) ? customerId : null;
+}
+function decodeAnalyticsEntityId(value) {
+  if (!value) return null;
+  if (isUuid(value)) return value;
+  if (value.startsWith("gid://")) {
+    const parts = value.split("/");
+    const candidate = parts[parts.length - 1];
+    return candidate && isUuid(candidate) ? candidate : null;
+  }
+  try {
+    const decoded = atob(value);
+    const parts = decoded.split(":");
+    const candidate = parts[parts.length - 1];
+    return candidate && isUuid(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function resolveDeviceInfo() {
+  const win = getWindow();
+  if (!win) {
+    return { deviceType: "server", deviceOs: null, deviceBrowser: null };
+  }
+  const ua = win.navigator.userAgent.toLowerCase();
+  const deviceType = /ipad|tablet|playbook|silk/.test(ua) ? "tablet" : /mobi|android|iphone|ipod|windows phone/.test(ua) ? "mobile" : "desktop";
+  let deviceOs = null;
+  if (ua.includes("windows")) {
+    deviceOs = "Windows";
+  } else if (ua.includes("mac os") || ua.includes("macintosh")) {
+    deviceOs = "macOS";
+  } else if (ua.includes("android")) {
+    deviceOs = "Android";
+  } else if (ua.includes("iphone") || ua.includes("ipad") || ua.includes("ios")) {
+    deviceOs = "iOS";
+  } else if (ua.includes("linux")) {
+    deviceOs = "Linux";
+  }
+  let deviceBrowser = null;
+  if (ua.includes("edg/")) {
+    deviceBrowser = "Edge";
+  } else if (ua.includes("firefox/")) {
+    deviceBrowser = "Firefox";
+  } else if (ua.includes("chrome/") && !ua.includes("edg/")) {
+    deviceBrowser = "Chrome";
+  } else if (ua.includes("safari/") && !ua.includes("chrome/")) {
+    deviceBrowser = "Safari";
+  }
+  return { deviceType, deviceOs, deviceBrowser };
+}
+function parseStoreSlugFromBase(basePath) {
+  if (!basePath) return null;
+  const segments = basePath.split("/").filter(Boolean);
+  if (segments.length < 2) return null;
+  const [mode, slug] = segments;
+  if (mode !== "preview" && mode !== "live") return null;
+  return slug ?? null;
+}
+function parseStoreSlugFromHostname(hostname) {
+  if (hostname === "localhost") return null;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) return null;
+  const [candidate] = hostname.split(".");
+  if (!candidate || candidate === "www") return null;
+  return candidate;
+}
+function normalizePath(pathname) {
+  return pathname.trim().length > 0 ? pathname : "/";
+}
+function toIsoTimestamp(value) {
+  if (value == null) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function buildUtmPayload(context) {
+  const persisted = getTrackingAttributionSnapshot();
+  return {
+    schemaVersion: TRACKING_SCHEMA_VERSION,
+    source: context.utmSource ?? persisted?.utm.source ?? null,
+    medium: context.utmMedium ?? persisted?.utm.medium ?? null,
+    campaign: context.utmCampaign ?? persisted?.utm.campaign ?? null,
+    term: context.utmTerm ?? persisted?.utm.term ?? null,
+    content: context.utmContent ?? persisted?.utm.content ?? null
+  };
+}
+function buildClickIdsPayload(context) {
+  const persisted = getTrackingAttributionSnapshot();
+  const clickIds = context.clickIds;
+  return {
+    schemaVersion: TRACKING_SCHEMA_VERSION,
+    capturedAt: toIsoTimestamp(clickIds?.capturedAt) ?? persisted?.clickIds.capturedAt ?? null,
+    gclid: clickIds?.gclid ?? persisted?.clickIds.gclid ?? null,
+    gbraid: clickIds?.gbraid ?? persisted?.clickIds.gbraid ?? null,
+    wbraid: clickIds?.wbraid ?? persisted?.clickIds.wbraid ?? null,
+    ttclid: clickIds?.ttclid ?? persisted?.clickIds.ttclid ?? null,
+    fbclid: clickIds?.fbclid ?? persisted?.clickIds.fbclid ?? null
+  };
+}
+function buildDefaultContext(storeFallback) {
+  const context = {};
+  const device = resolveDeviceInfo();
+  const win = getWindow();
+  if (win) {
+    const { pathname, search, hostname } = win.location;
+    context.path = pathname + search;
+    context.referrer = win.document.referrer.length > 0 ? win.document.referrer : null;
+    const params = new URLSearchParams(win.location.search);
+    context.utmSource = params.get("utm_source");
+    context.utmMedium = params.get("utm_medium");
+    context.utmCampaign = params.get("utm_campaign");
+    context.utmTerm = params.get("utm_term");
+    context.utmContent = params.get("utm_content");
+    context.storeSlug = parseStoreSlugFromBase(pathname) ?? parseStoreSlugFromHostname(hostname) ?? void 0;
+    context.deviceType = device.deviceType;
+    context.deviceOs = device.deviceOs;
+    context.deviceBrowser = device.deviceBrowser;
+  }
+  if (!context.deviceType) {
+    context.deviceType = "unknown";
+  }
+  if (!context.storeSlug) {
+    context.storeSlug = storeFallback;
+  }
+  context.deviceOs ??= null;
+  context.deviceBrowser ??= null;
+  return context;
+}
+function normalizeEventContext(context, storeFallback) {
+  const defaults = buildDefaultContext(storeFallback);
+  const merged = { ...defaults, ...context };
+  return {
+    context: merged,
+    storeSlug: merged.storeSlug ?? null
+  };
+}
+function isIngestResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const response = value;
+  return typeof response.acceptedCount === "number" && typeof response.duplicateCount === "number" && typeof response.rejectedCount === "number" && Array.isArray(response.errors);
+}
+function extractErrorMessage(response) {
+  return response.json().then((payload) => {
+    if (typeof payload.error === "string" && payload.error.length > 0) {
+      return payload.error;
+    }
+    const firstMessage = Array.isArray(payload.details) ? payload.details.map((error) => typeof error?.message === "string" ? error.message : null).find((message) => message !== null) : null;
+    if (firstMessage) {
+      return firstMessage;
+    }
+    return `Analytics ingest failed with status ${response.status}`;
+  }).catch(() => `Analytics ingest failed with status ${response.status}`);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveTrackEvent(eventName) {
+  const normalized = eventName.startsWith("analytics.") ? eventName.slice("analytics.".length) : eventName;
+  if (normalized in ANALYTICS_PRESET_EVENT_MAP) {
+    return { eventType: ANALYTICS_PRESET_EVENT_MAP[normalized] };
+  }
+  return {
+    eventType: "analytics.custom",
+    customEventName: eventName
+  };
+}
+function createAnalyticsOperations(client) {
+  captureLandingTrackingAttribution();
+  const endpoint = (() => {
+    try {
+      const parsedEndpoint = new URL(client.config.endpoint);
+      return `${parsedEndpoint.origin}${ANALYTICS_PATH}`;
+    } catch {
+      return null;
+    }
+  })();
+  const configStoreSlug = client.config.storeSlug;
+  async function sendEvent(eventType, properties, context) {
+    if (!endpoint) {
+      return neverthrow.err(new errors.NetworkError("Invalid storefront endpoint"));
+    }
+    const resolved = normalizeEventContext(context, configStoreSlug);
+    const storeSlug = resolved.storeSlug;
+    const eventContext = resolved.context;
+    if (!storeSlug) {
+      return neverthrow.err(new errors.NetworkError("Missing storeSlug. Provide storeSlug in client config or event context."));
+    }
+    const now = new Date(eventContext.occurredAt ?? Date.now());
+    const nowIso = Number.isNaN(now.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : now.toISOString();
+    const customerId = eventContext.customerId === void 0 ? parseCustomerIdFromToken(client.getCustomerToken()) : eventContext.customerId;
+    const event = {
+      schemaVersion: TRACKING_SCHEMA_VERSION,
+      eventId: randomUuid(),
+      eventType,
+      occurredAt: nowIso,
+      sessionId: eventContext.sessionId ?? getSessionId(now.getTime()),
+      visitorId: eventContext.visitorId ?? getOrCreateVisitorId(),
+      customerId: customerId ?? null,
+      consentState: eventContext.consentState ?? "unknown",
+      context: {
+        schemaVersion: TRACKING_SCHEMA_VERSION,
+        path: normalizePath(eventContext.path ?? "/")
+      },
+      referrer: eventContext.referrer ?? null,
+      utm: buildUtmPayload(eventContext),
+      clickIds: buildClickIdsPayload(eventContext),
+      device: {
+        deviceType: eventContext.deviceType ?? "unknown",
+        deviceOs: eventContext.deviceOs ?? null,
+        deviceBrowser: eventContext.deviceBrowser ?? null
+      },
+      properties
+    };
+    const payload = {
+      storeSlug,
+      events: [event]
+    };
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const message = response.headers.get("content-type")?.includes("application/json") ? await extractErrorMessage(response) : `Analytics ingest failed with status ${response.status}`;
+        return neverthrow.err(new errors.NetworkError(message));
+      }
+      const parsed = await response.json();
+      if (!isIngestResponse(parsed)) {
+        return neverthrow.err(new errors.NetworkError("Analytics response shape is invalid"));
+      }
+      return neverthrow.ok(parsed);
+    } catch (error) {
+      return neverthrow.err(
+        new errors.NetworkError("Failed to send analytics event", { cause: error instanceof Error ? error : void 0 })
+      );
+    }
+  }
+  async function track(eventName, eventPayload, context) {
+    const normalized = resolveTrackEvent(eventName);
+    if (normalized.eventType !== "analytics.custom") {
+      switch (normalized.eventType) {
+        case "analytics.page_view": {
+          const eventContext = context ?? (isPlainObject(eventPayload) ? eventPayload : void 0);
+          return sendEvent("analytics.page_view", {}, eventContext);
+        }
+        case "analytics.product_view": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("productId is required"));
+          }
+          const payload = eventPayload;
+          const decodedProductId = decodeAnalyticsEntityId(payload.productId);
+          if (!decodedProductId) {
+            return neverthrow.err(new errors.NetworkError("Invalid productId"));
+          }
+          const decodedVariantId = decodeAnalyticsEntityId(payload.variantId);
+          return sendEvent(
+            "analytics.product_view",
+            { productId: decodedProductId, variantId: decodedVariantId },
+            context
+          );
+        }
+        case "analytics.collection_view": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("collectionId is required"));
+          }
+          const payload = eventPayload;
+          const decodedCollectionId = decodeAnalyticsEntityId(payload.collectionId);
+          if (!decodedCollectionId) {
+            return neverthrow.err(new errors.NetworkError("Invalid collectionId"));
+          }
+          return sendEvent("analytics.collection_view", { collectionId: decodedCollectionId }, context);
+        }
+        case "analytics.search_performed": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("query is required"));
+          }
+          const payload = eventPayload;
+          const trimmed = payload.query.trim();
+          if (!trimmed) {
+            return neverthrow.err(new errors.NetworkError("query is required"));
+          }
+          return sendEvent(
+            "analytics.search_performed",
+            { query: trimmed, resultsCount: Math.max(0, Math.floor(payload.resultsCount)) },
+            context
+          );
+        }
+        case "analytics.add_to_cart": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          const payload = eventPayload;
+          const cartId = decodeAnalyticsEntityId(payload.cartId);
+          if (!cartId) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          return sendEvent(
+            "analytics.add_to_cart",
+            {
+              cartId,
+              quantity: Math.max(1, Math.floor(payload.quantity)),
+              itemsCount: Math.max(0, Math.floor(payload.itemsCount)),
+              cartValueCents: toCents(payload.cartValue)
+            },
+            context
+          );
+        }
+        case "analytics.remove_from_cart": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          const payload = eventPayload;
+          const cartId = decodeAnalyticsEntityId(payload.cartId);
+          if (!cartId) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          return sendEvent(
+            "analytics.remove_from_cart",
+            {
+              cartId,
+              quantity: Math.max(1, Math.floor(payload.quantity)),
+              itemsCount: Math.max(0, Math.floor(payload.itemsCount)),
+              cartValueCents: toCents(payload.cartValue)
+            },
+            context
+          );
+        }
+        case "analytics.checkout_started": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          const payload = eventPayload;
+          const decodedCartId = decodeAnalyticsEntityId(payload.cartId);
+          if (!decodedCartId) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          return sendEvent("analytics.checkout_started", { cartId: decodedCartId }, context);
+        }
+        case "analytics.checkout_step_completed": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          const payload = eventPayload;
+          const decodedCartId = decodeAnalyticsEntityId(payload.cartId);
+          if (!decodedCartId) {
+            return neverthrow.err(new errors.NetworkError("Invalid cartId"));
+          }
+          return sendEvent("analytics.checkout_step_completed", { cartId: decodedCartId, step: payload.step }, context);
+        }
+        case "analytics.checkout_completed": {
+          if (!isPlainObject(eventPayload)) {
+            return neverthrow.err(new errors.NetworkError("Invalid orderId or cartId"));
+          }
+          const payload = eventPayload;
+          const orderId = decodeAnalyticsEntityId(payload.orderId);
+          const cartId = decodeAnalyticsEntityId(payload.cartId);
+          if (!orderId || !cartId) {
+            return neverthrow.err(new errors.NetworkError("Invalid orderId or cartId"));
+          }
+          return sendEvent(
+            "analytics.checkout_completed",
+            {
+              orderId,
+              cartId,
+              orderTotalCents: toCents(payload.orderTotal)
+            },
+            context
+          );
+        }
+      }
+    }
+    const properties = isPlainObject(eventPayload) ? eventPayload : {};
+    return sendEvent(
+      "analytics.custom",
+      { ...properties, eventName: normalized.customEventName ?? eventName },
+      context
+    );
+  }
+  return {
+    track
+  };
+}
+const AVAILABLE_SHIPPING_RATES_QUERY = `
+query AvailableShippingRates {
+  availableShippingRates {
+    id
+    name
+    price
+    minOrderAmount
+    estimatedDaysMin
+    estimatedDaysMax
+    isFree
+  }
+}
+`;
+function mapShippingRate(data) {
+  return {
+    id: data.id,
+    name: data.name,
+    price: data.price,
+    minOrderAmount: data.minOrderAmount,
+    estimatedDaysMin: data.estimatedDaysMin,
+    estimatedDaysMax: data.estimatedDaysMax,
+    isFree: data.isFree
+  };
+}
+function createShippingOperations(client) {
+  return {
+    async getAvailableRates() {
+      const result = await client.query(
+        { query: AVAILABLE_SHIPPING_RATES_QUERY },
+        { cache: true }
+      );
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+      if (!result.value.availableShippingRates) {
+        return neverthrow.err(new errors.NotFoundError("Shipping rates not available"));
+      }
+      return neverthrow.ok(result.value.availableShippingRates.map(mapShippingRate));
+    }
+  };
+}
+const DEFAULT_CACHE_TTL = 5 * 60 * 1e3;
+function createStorefrontClient(config) {
+  const storage = config.storage ?? createDefaultAdapter();
+  const queryCache = createQueryCache();
+  const cacheTTL = config.cacheTTL ?? DEFAULT_CACHE_TTL;
+  const graphqlClient = createGraphQLClient({
+    endpoint: config.endpoint,
+    apiKey: config.apiKey,
+    getCartToken: () => storage.get(CART_TOKEN_KEY),
+    getCustomerToken: () => storage.get(CUSTOMER_TOKEN_KEY),
+    cache: queryCache,
+    cacheTTL
+  });
+  const client = {
+    config,
+    _graphql: graphqlClient,
+    _storage: storage,
+    _queryCache: queryCache,
+    cache: {
+      clear() {
+        queryCache.clear();
+      }
+    },
+    // Placeholder - will be assigned below
+    products: null,
+    collections: null,
+    categories: null,
+    cart: null,
+    checkout: null,
+    payments: null,
+    auth: null,
+    account: null,
+    shipping: null,
+    analytics: null,
+    query(request, options) {
+      return graphqlClient.query(request, options);
+    },
+    mutate(request) {
+      return graphqlClient.mutate(request);
+    },
+    getCartToken() {
+      return storage.get(CART_TOKEN_KEY);
+    },
+    setCartToken(token) {
+      storage.set(CART_TOKEN_KEY, token);
+    },
+    clearCartToken() {
+      storage.remove(CART_TOKEN_KEY);
+    },
+    getCustomerToken() {
+      return storage.get(CUSTOMER_TOKEN_KEY);
+    },
+    setCustomerToken(token) {
+      storage.set(CUSTOMER_TOKEN_KEY, token);
+    },
+    clearCustomerToken() {
+      storage.remove(CUSTOMER_TOKEN_KEY);
+    }
+  };
+  client.products = createProductsOperations(client);
+  client.collections = createCollectionsOperations(client);
+  client.categories = createCategoriesOperations(client);
+  client.cart = createCartOperations(client, storage);
+  client.checkout = createCheckoutOperations(client, storage);
+  client.payments = createPaymentsOperations(client);
+  client.auth = createAuthOperations(client, storage);
+  client.account = createAccountOperations(client, storage);
+  client.shipping = createShippingOperations(client);
+  client.analytics = createAnalyticsOperations(client);
+  return client;
+}
+exports.AuthError = errors.AuthError;
+exports.GraphQLError = errors.GraphQLError;
+exports.NetworkError = errors.NetworkError;
+exports.NotFoundError = errors.NotFoundError;
+exports.StateError = errors.StateError;
+exports.StorefrontError = errors.StorefrontError;
+exports.ValidationError = errors.ValidationError;
+exports.CART_TOKEN_KEY = CART_TOKEN_KEY;
+exports.CUSTOMER_TOKEN_KEY = CUSTOMER_TOKEN_KEY;
+exports.createDefaultAdapter = createDefaultAdapter;
+exports.createLocalStorageAdapter = createLocalStorageAdapter;
+exports.createMemoryAdapter = createMemoryAdapter;
+exports.createQueryCache = createQueryCache;
+exports.createStorefrontClient = createStorefrontClient;
+exports.extractUserErrors = extractUserErrors;
+//# sourceMappingURL=index.cjs.map