@shopify/hydrogen 2026.4.5 → 2026.10.0-preview.2

package/dist/development/core/cart/cart.mjs

@@ -0,0 +1,1707 @@
+import { getLogger } from "../logging/logging.mjs";
+import { createObservable } from "../observable.mjs";
+import { SHOPIFY_STOREFRONT_STANDARD_ACTIONS_SCRIPT, VISITOR_CONSENT_COLLECTED_EVENT } from "../shopify-scripts/constants.mjs";
+import { getCartAttributeFormEntries } from "./form.mjs";
+import { DEFAULT_MINIMUM_QUANTITY, sanitizeQuantity } from "./quantity.mjs";
+import { createCartState, createEmptyCartState, createEmptyErrorGroup } from "./state.mjs";
+import { syncQuantityInputs } from "./sync-quantity-inputs.mjs";
+
+//#region src/core/cart/cart.ts
+const log = getLogger("cart");
+const OPTIMISTIC_LINE_ID_PREFIX = "optimistic:";
+const LINE_KEY_PREFIX = "line:";
+const MERCHANDISE_KEY_PREFIX = "merchandise:";
+const DISCOUNT_KEY_PREFIX = "discount:";
+const NOTE_KEY = "note";
+const ATTRIBUTES_KEY = "attributes";
+const DISCOUNT_CODES_KEY = "discount-codes";
+const REVALIDATION_ERROR_KEY = "cart-revalidation";
+const TRANSACTION_EVENT_TOKEN_KEY = "__shopifyHydrogenCartTransaction";
+const DEFAULT_ADD_QUANTITY = 1;
+const NOOP = () => {};
+const EMPTY_QUANTITY = 0;
+const FNV1A_OFFSET_BASIS = 2166136261;
+const FNV1A_PRIME = 16777619;
+const CART_REVALIDATION_ERROR_MESSAGE = "Something went wrong refreshing your cart. Please try again.";
+const STANDARD_ACTION_TIMEOUT_IN_MS = 3e4;
+var CartNetworkError = class extends Error {
+	status;
+	constructor(status) {
+		super("Something went wrong updating your cart. Please try again.");
+		this.name = "CartNetworkError";
+		this.status = status;
+	}
+};
+function defineTransactionTypes(definitions) {
+	return definitions;
+}
+function getTransactionDefinition(type) {
+	return CART_TRANSACTION_TYPES[type];
+}
+let configuredCartEndpoint = null;
+let hasConfiguredUpdateCart = false;
+let standardActionsPromise = null;
+const connectedCartStores = /* @__PURE__ */ new Set();
+let cartConsentListenerAttached = false;
+function getLines(cart) {
+	return cart.lines.nodes;
+}
+function setLines(cart, lines) {
+	if (cart.lines.nodes === lines) return cart;
+	return {
+		...cart,
+		lines: {
+			...cart.lines,
+			nodes: lines
+		}
+	};
+}
+function reconcileCartLines(cart, lines) {
+	const currentLines = getLines(cart);
+	if (currentLines === lines) return cart;
+	const currentLoadedQuantity = currentLines.reduce((total, line) => total + line.quantity, EMPTY_QUANTITY);
+	const nextLoadedQuantity = lines.reduce((total, line) => total + line.quantity, EMPTY_QUANTITY);
+	const totalQuantity = cart.totalQuantity + nextLoadedQuantity - currentLoadedQuantity;
+	return setLines({
+		...cart,
+		totalQuantity
+	}, lines);
+}
+function normalizeKeys(keys) {
+	if (keys === void 0) return [];
+	return typeof keys === "string" ? [keys] : [...new Set(keys)];
+}
+function lineKey(lineId) {
+	return `${LINE_KEY_PREFIX}${lineId}`;
+}
+function compareAttributes(left, right) {
+	if (left.key !== right.key) return left.key < right.key ? -1 : 1;
+	if (left.value === null) return right.value === null ? 0 : -1;
+	if (right.value === null) return 1;
+	if (left.value !== right.value) return left.value < right.value ? -1 : 1;
+	return 0;
+}
+function normalizeAttributes(attributes) {
+	if (!attributes?.length) return [];
+	return attributes.toSorted(compareAttributes);
+}
+function sameAttributes(left, right) {
+	const normalizedLeft = normalizeAttributes(left);
+	const normalizedRight = normalizeAttributes(right);
+	if (normalizedLeft.length !== normalizedRight.length) return false;
+	return normalizedLeft.every((attribute, index) => attribute.key === normalizedRight[index].key && attribute.value === normalizedRight[index].value);
+}
+function hashString(value) {
+	let hash = FNV1A_OFFSET_BASIS;
+	for (const character of value) {
+		hash ^= character.codePointAt(0) ?? 0;
+		hash = Math.imul(hash, FNV1A_PRIME);
+	}
+	return (hash >>> 0).toString(36);
+}
+function merchandiseKey(line) {
+	return `${MERCHANDISE_KEY_PREFIX}${JSON.stringify({
+		merchandiseId: line.merchandiseId,
+		sellingPlanId: line.sellingPlanId ?? null,
+		attributes: normalizeAttributes(line.attributes)
+	})}`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isAttribute(value) {
+	return isRecord(value) && typeof value.key === "string" && typeof value.value === "string";
+}
+function parseMerchandiseKey(key) {
+	if (!key.startsWith(MERCHANDISE_KEY_PREFIX)) return void 0;
+	const value = key.slice(12);
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return;
+	}
+	if (!isRecord(parsed) || typeof parsed.merchandiseId !== "string") return void 0;
+	if (parsed.sellingPlanId !== null && typeof parsed.sellingPlanId !== "string") return void 0;
+	if (!Array.isArray(parsed.attributes) || !parsed.attributes.every(isAttribute)) return void 0;
+	const attributes = normalizeAttributes(parsed.attributes);
+	return {
+		merchandiseId: parsed.merchandiseId,
+		...parsed.sellingPlanId ? { sellingPlanId: parsed.sellingPlanId } : {},
+		...attributes.length > 0 ? { attributes } : {}
+	};
+}
+function optimisticLineId(line) {
+	const sellingPlanSuffix = line.sellingPlanId ? `:${line.sellingPlanId}` : "";
+	const attributes = normalizeAttributes(line.attributes);
+	const attributesSuffix = attributes.length > 0 ? `:${hashString(JSON.stringify(attributes))}` : "";
+	return `${OPTIMISTIC_LINE_ID_PREFIX}${line.merchandiseId}${sellingPlanSuffix}${attributesSuffix}`;
+}
+function cartResponseFromStandardEvent(cart) {
+	const response = cart;
+	const lines = Array.isArray(cart.lines) ? cart.lines : response.lines.nodes;
+	const connection = Array.isArray(cart.lines) ? { nodes: lines } : {
+		...response.lines,
+		nodes: lines
+	};
+	return {
+		...response,
+		lines: connection
+	};
+}
+function isPromiseLike(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function shallowEqualRecord(left, right) {
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = Object.keys(leftRecord);
+	if (leftKeys.length !== Object.keys(rightRecord).length) return false;
+	return leftKeys.every((key) => Object.is(leftRecord[key], rightRecord[key]));
+}
+function reuseLineReferences(previous, next) {
+	const previousById = new Map(previous.map((line) => [line.id, line]));
+	let changed = previous.length !== next.length;
+	const shared = next.map((line, index) => {
+		const prior = previousById.get(line.id);
+		const value = prior && shallowEqualRecord(prior, line) ? prior : line;
+		if (previous[index] !== value) changed = true;
+		return value;
+	});
+	return changed ? shared : previous;
+}
+function sameSet(left, right) {
+	return left.size === right.size && [...left].every((value) => right.has(value));
+}
+function reuseVisibleReferences(previous, next) {
+	const lines = reuseLineReferences(getLines(previous.data), getLines(next.data));
+	const dataWithLines = setLines(next.data, lines);
+	const data = shallowEqualRecord(previous.data, dataWithLines) ? previous.data : dataWithLines;
+	const pendingLines = sameSet(previous.pending.lines, next.pending.lines) ? previous.pending.lines : next.pending.lines;
+	const pendingDiscountCodes = sameSet(previous.pending.discountCodes, next.pending.discountCodes) ? previous.pending.discountCodes : next.pending.discountCodes;
+	const nextPending = {
+		lines: pendingLines,
+		note: next.pending.note,
+		attributes: next.pending.attributes,
+		discountCodes: pendingDiscountCodes,
+		cost: next.pending.cost
+	};
+	const pending = shallowEqualRecord(previous.pending, nextPending) ? previous.pending : nextPending;
+	if (previous.data === data && previous.loading === next.loading && previous.revalidating === next.revalidating && previous.errors === next.errors && previous.pending === pending) return previous;
+	return {
+		...next,
+		data,
+		pending
+	};
+}
+function derivePending(state, transactions) {
+	const lines = /* @__PURE__ */ new Set();
+	const discountCodes = /* @__PURE__ */ new Set();
+	let note = false;
+	let attributes = false;
+	let cost = false;
+	for (const transaction of transactions) for (const key of transaction.pendingKeys) {
+		if (key === NOTE_KEY) note = true;
+		if (key === ATTRIBUTES_KEY) attributes = true;
+		if (key.startsWith(LINE_KEY_PREFIX)) {
+			lines.add(key.slice(5));
+			cost = true;
+		}
+		if (key.startsWith(DISCOUNT_KEY_PREFIX)) {
+			discountCodes.add(key.slice(9));
+			cost = true;
+		}
+		const addition = parseMerchandiseKey(key);
+		if (!addition) continue;
+		const line = findLineForAddition(getLines(state.data), addition);
+		if (line) lines.add(line.id);
+		cost = true;
+	}
+	return {
+		lines,
+		note,
+		attributes,
+		discountCodes,
+		cost
+	};
+}
+function projectVisibleState(store) {
+	let state = store.settled;
+	for (const transaction of store.transactions) state = transaction.projectPayload(state);
+	state = {
+		...state,
+		pending: derivePending(state, store.transactions)
+	};
+	for (const error of store.projectedErrors) state = error.project(state);
+	if (store.revalidation.visible) state = {
+		...state,
+		revalidating: true
+	};
+	return state;
+}
+function publishVisibleState(store) {
+	const previous = store.observable.state;
+	const next = reuseVisibleReferences(previous, projectVisibleState(store));
+	if (configuredCartEndpoint && previous !== next) {
+		const previousLines = new Map(getLines(previous.data).map((line) => [line.id, line]));
+		const changedQuantities = getLines(next.data).filter((line) => previousLines.get(line.id)?.quantity !== line.quantity).map((line) => ({
+			id: line.id,
+			quantity: line.quantity
+		}));
+		if (changedQuantities.length > 0) syncQuantityInputs(changedQuantities, configuredCartEndpoint);
+	}
+	store.observable.setState(next);
+}
+function sharesKey(left, right) {
+	const rightKeys = new Set(right);
+	return left.some((key) => rightKeys.has(key));
+}
+function clearProjectedErrors(store, keys) {
+	if (keys.length === 0) return;
+	store.projectedErrors = store.projectedErrors.filter((error) => !sharesKey(error.keys, keys));
+}
+function addProjectedError(store, keys, projector) {
+	const timestampMs = Date.now();
+	store.projectedErrors.push({
+		keys,
+		project: (state) => projector(state, timestampMs)
+	});
+}
+function createOwner(store, keys) {
+	if (keys.length === 0) return null;
+	const owner = {
+		controller: new AbortController(),
+		token: {}
+	};
+	for (const key of keys) {
+		store.keyedOwners.get(key)?.controller.abort();
+		store.keyedOwners.set(key, owner);
+	}
+	return owner;
+}
+function ownsSignalKeys(store, transaction) {
+	if (!transaction.owner) return true;
+	return transaction.signalKeys.every((key) => store.keyedOwners.get(key)?.token === transaction.owner?.token);
+}
+function releaseSignalKeys(store, transaction) {
+	if (!transaction.owner) return;
+	for (const key of transaction.signalKeys) if (store.keyedOwners.get(key)?.token === transaction.owner.token) store.keyedOwners.delete(key);
+}
+function getErrorGroup(map, key) {
+	const existing = map.get(key);
+	if (existing) return existing;
+	const group = createEmptyErrorGroup();
+	map.set(key, group);
+	return group;
+}
+function toCartUserError(error) {
+	return {
+		code: error.code ?? null,
+		message: error.message,
+		...error.field ? { field: error.field } : {}
+	};
+}
+function toCartWarning(warning) {
+	return {
+		code: warning.code ?? "UNKNOWN",
+		message: warning.message
+	};
+}
+function findFieldIndex(field, ...keys) {
+	if (!field) return void 0;
+	const index = field.findIndex((part, fieldIndex) => keys.includes(part) && /^\d+$/.test(field[fieldIndex + 1] ?? ""));
+	return index === -1 ? void 0 : Number(field[index + 1]);
+}
+function isCartLineId(value) {
+	return typeof value === "string" && value.startsWith("gid://shopify/CartLine/");
+}
+function groupLineErrors(failure, lineIds) {
+	const lines = /* @__PURE__ */ new Map();
+	const cart = createEmptyErrorGroup();
+	for (const error of failure?.userErrors ?? []) {
+		const lineIndex = findFieldIndex(error.field, "lines", "lineIds");
+		const lineId = lineIndex === void 0 ? void 0 : lineIds[lineIndex];
+		(lineId ? getErrorGroup(lines, lineId) : cart).userErrors.push(toCartUserError(error));
+	}
+	for (const warning of failure?.warnings ?? []) (isCartLineId(warning.target) ? getErrorGroup(lines, warning.target) : cart).warnings.push(toCartWarning(warning));
+	return {
+		lines,
+		cart
+	};
+}
+function isDiscountWarning(code) {
+	return typeof code === "string" && code.startsWith("DISCOUNT_");
+}
+function addDiscountWarning(codes, cart, warning, nonApplicableCodes) {
+	if (!isDiscountWarning(warning.code) || nonApplicableCodes.length === 0) {
+		cart.warnings.push(toCartWarning(warning));
+		return;
+	}
+	for (const code of nonApplicableCodes) getErrorGroup(codes, code).warnings.push(toCartWarning(warning));
+}
+function groupDiscountErrors(failure, discountCodes, resolvedDiscountCodes) {
+	const codes = /* @__PURE__ */ new Map();
+	const cart = createEmptyErrorGroup();
+	for (const error of failure?.userErrors ?? []) {
+		const codeIndex = findFieldIndex(error.field, "discountCodes");
+		const code = codeIndex === void 0 ? void 0 : discountCodes[codeIndex];
+		(code ? getErrorGroup(codes, code) : cart).userErrors.push(toCartUserError(error));
+	}
+	const nonApplicableCodes = resolvedDiscountCodes?.filter((code) => !code.applicable).map((code) => code.code) ?? [];
+	for (const warning of failure?.warnings ?? []) addDiscountWarning(codes, cart, warning, nonApplicableCodes);
+	return {
+		discountCodes: codes,
+		cart
+	};
+}
+function groupAttributeErrors(failure, attributes) {
+	const attributeErrors = /* @__PURE__ */ new Map();
+	const cart = createEmptyErrorGroup();
+	for (const error of failure?.userErrors ?? []) {
+		const attributeIndex = findFieldIndex(error.field, "attributes");
+		const key = attributeIndex === void 0 ? void 0 : attributes[attributeIndex]?.key;
+		(key ? getErrorGroup(attributeErrors, key) : cart).userErrors.push(toCartUserError(error));
+	}
+	for (const warning of failure?.warnings ?? []) cart.warnings.push(toCartWarning(warning));
+	return {
+		attributes: attributeErrors,
+		cart
+	};
+}
+function toCartErrorGroup(failure) {
+	return {
+		userErrors: (failure?.userErrors ?? []).map(toCartUserError),
+		warnings: (failure?.warnings ?? []).map(toCartWarning)
+	};
+}
+function extractCartActionFailure(error) {
+	const cause = error?.cause;
+	return Array.isArray(cause?.userErrors) || Array.isArray(cause?.warnings) ? cause : void 0;
+}
+function createNetworkEntry(error) {
+	if (error instanceof CartNetworkError) return {
+		message: error.message,
+		status: error.status
+	};
+	return { message: error instanceof Error ? error.message : "Cart update failed" };
+}
+function mergeErrorGroups(left, right) {
+	return {
+		userErrors: [...left.userErrors, ...right.userErrors],
+		warnings: [...left.warnings, ...right.warnings]
+	};
+}
+function writeNetworkError(state, error, timestampMs) {
+	return {
+		...state,
+		errors: {
+			...state.errors,
+			network: [...state.errors.network, createNetworkEntry(error)],
+			networkUpdatedAt: timestampMs,
+			lastUpdatedAt: timestampMs
+		}
+	};
+}
+function projectLineErrors(state, failure, lineIds, timestampMs) {
+	if (!failure) return state;
+	const grouped = groupLineErrors(failure, lineIds);
+	return {
+		...state,
+		errors: {
+			...state.errors,
+			lines: new Map([...state.errors.lines, ...grouped.lines]),
+			cart: mergeErrorGroups(state.errors.cart, grouped.cart),
+			linesUpdatedAt: timestampMs,
+			cartUpdatedAt: timestampMs,
+			lastUpdatedAt: timestampMs
+		}
+	};
+}
+function projectDiscountErrors(state, failure, discountCodes, timestampMs, resolvedDiscountCodes) {
+	if (!failure) return state;
+	const grouped = groupDiscountErrors(failure, discountCodes, resolvedDiscountCodes);
+	return {
+		...state,
+		errors: {
+			...state.errors,
+			discountCodes: new Map([...state.errors.discountCodes, ...grouped.discountCodes]),
+			cart: mergeErrorGroups(state.errors.cart, grouped.cart),
+			discountCodesUpdatedAt: timestampMs,
+			cartUpdatedAt: timestampMs,
+			lastUpdatedAt: timestampMs
+		}
+	};
+}
+function projectNoteErrors(state, failure, timestampMs) {
+	if (!failure) return state;
+	return {
+		...state,
+		errors: {
+			...state.errors,
+			note: toCartErrorGroup(failure),
+			noteUpdatedAt: timestampMs,
+			lastUpdatedAt: timestampMs
+		}
+	};
+}
+function projectAttributeErrors(state, failure, attributes, timestampMs) {
+	if (!failure) return state;
+	const grouped = groupAttributeErrors(failure, attributes);
+	return {
+		...state,
+		errors: {
+			...state.errors,
+			attributes: new Map([...state.errors.attributes, ...grouped.attributes]),
+			cart: mergeErrorGroups(state.errors.cart, grouped.cart),
+			attributesUpdatedAt: timestampMs,
+			cartUpdatedAt: timestampMs,
+			lastUpdatedAt: timestampMs
+		}
+	};
+}
+function extractProductDetails(detail) {
+	const products = detail?.products;
+	if (!Array.isArray(products)) return [];
+	return products.filter((product) => typeof product === "object" && product !== null && "id" in product && typeof product.id === "string");
+}
+function getLineSellingPlanId(line) {
+	return line.sellingPlanAllocation?.sellingPlan.id;
+}
+function hasKnownLineIdentity(line) {
+	return Object.hasOwn(line, "attributes") && Object.hasOwn(line, "sellingPlanAllocation");
+}
+function hasAdditionIdentityDetails(addition) {
+	return addition.sellingPlanId !== void 0 || normalizeAttributes(addition.attributes).length > 0;
+}
+function lineMatchesAddition(line, addition) {
+	if (line.id === optimisticLineId(addition)) return true;
+	if (line.merchandise?.id !== addition.merchandiseId) return false;
+	if (!hasKnownLineIdentity(line)) return !hasAdditionIdentityDetails(addition);
+	if (getLineSellingPlanId(line) !== addition.sellingPlanId) return false;
+	return sameAttributes(line.attributes, addition.attributes);
+}
+function findLineForAddition(lines, addition) {
+	return lines.find((line) => lineMatchesAddition(line, addition));
+}
+function findAvailableLineForAddition(lines, addition, usedLineIds) {
+	return lines.find((line) => !usedLineIds.has(line.id) && lineMatchesAddition(line, addition));
+}
+function findResponseLineForAddition(serverLines, currentLines, addition, usedLineIds, canInferSingleLine, remainingAdditions) {
+	const exact = findAvailableLineForAddition(serverLines, addition, usedLineIds);
+	if (exact) return exact;
+	const currentLine = findLineForAddition(currentLines, addition);
+	const matchingCurrentLine = serverLines.find((line) => !usedLineIds.has(line.id) && line.id === currentLine?.id);
+	if (matchingCurrentLine) return matchingCurrentLine;
+	const currentLineIds = new Set(currentLines.map((line) => line.id));
+	const newLines = serverLines.filter((line) => !usedLineIds.has(line.id) && !currentLineIds.has(line.id));
+	if (remainingAdditions === newLines.length && newLines.length === 1) return newLines[0];
+	return canInferSingleLine ? serverLines.find((line) => !usedLineIds.has(line.id)) : void 0;
+}
+function withAdditionMerchandise(line, addition, products) {
+	if (line.merchandise) return line;
+	const product = products.find((candidate) => candidate.id === addition.merchandiseId);
+	if (!product) return line;
+	const { price: _price, ...merchandise } = product;
+	return {
+		...line,
+		merchandise
+	};
+}
+function replaceOrPrependLine(lines, previous, next) {
+	if (previous) return lines.map((line) => line === previous ? next : line);
+	if (lines.some((line) => line.id === next.id)) return lines.map((line) => line.id === next.id ? next : line);
+	return [next, ...lines];
+}
+function mergeAddResponseLines(currentLines, serverLines, payload) {
+	let lines = currentLines;
+	const usedLineIds = /* @__PURE__ */ new Set();
+	const canInferSingleLine = payload.lines.length === 1 && serverLines.length === 1;
+	for (const addition of payload.lines) {
+		const remainingAdditions = payload.lines.length - usedLineIds.size;
+		const serverLine = findResponseLineForAddition(serverLines, lines, addition, usedLineIds, canInferSingleLine, remainingAdditions);
+		if (!serverLine) continue;
+		usedLineIds.add(serverLine.id);
+		const previous = findLineForAddition(lines, addition) ?? lines.find((line) => line.id === serverLine.id);
+		const next = withAdditionMerchandise(serverLine, addition, payload.products);
+		lines = replaceOrPrependLine(lines, previous, mergeServerLine(previous, next));
+	}
+	return lines;
+}
+function resolveAddLineIds(currentLines, serverLines, payload) {
+	const usedLineIds = /* @__PURE__ */ new Set();
+	const canInferSingleLine = payload.lines.length === 1 && serverLines.length === 1;
+	return payload.lines.map((addition) => {
+		const serverLine = findResponseLineForAddition(serverLines, currentLines, addition, usedLineIds, canInferSingleLine, payload.lines.length - usedLineIds.size);
+		if (serverLine) {
+			usedLineIds.add(serverLine.id);
+			return serverLine.id;
+		}
+		return findLineForAddition(currentLines, addition)?.id ?? "";
+	});
+}
+function getAddErrorKeys(payload, lineIds, failure) {
+	const keys = new Set(payload.lines.map(merchandiseKey));
+	for (const lineId of lineIds) if (lineId) keys.add(lineKey(lineId));
+	for (const warning of failure?.warnings ?? []) if (isCartLineId(warning.target)) keys.add(lineKey(warning.target));
+	return [...keys];
+}
+function mergeServerLine(previous, next) {
+	if (!previous) return next;
+	const merchandise = next.merchandise ? {
+		...previous.merchandise,
+		...next.merchandise
+	} : previous.merchandise;
+	return {
+		...previous,
+		...next,
+		...merchandise ? { merchandise } : {}
+	};
+}
+function hasProjectedErrors(result) {
+	return (result?.userErrors?.length ?? 0) > 0 || (result?.warnings?.length ?? 0) > 0;
+}
+function transportAddToCart(payload, signal, updateCart, cartId) {
+	return updateCart({
+		...cartId && { cartId },
+		lines: payload.lines
+	}, {
+		signal,
+		...payload.eventDetail && { event: { detail: payload.eventDetail } }
+	});
+}
+const CART_TRANSACTION_TYPES = defineTransactionTypes({
+	add_to_cart: {
+		payload: {},
+		transport: transportAddToCart,
+		projectPayload: (state, payload) => {
+			let lines = getLines(state.data);
+			let linesChanged = false;
+			for (const addition of payload.lines) {
+				const existing = findLineForAddition(lines, addition);
+				if (existing) {
+					lines = lines.map((line) => line === existing ? {
+						...line,
+						quantity: line.quantity + addition.quantity
+					} : line);
+					linesChanged = true;
+					continue;
+				}
+				const product = payload.products.find((candidate) => candidate.id === addition.merchandiseId);
+				if (!product) continue;
+				const { price, ...merchandise } = product;
+				const amount = price ?? {
+					amount: "0",
+					currencyCode: ""
+				};
+				lines = [{
+					id: optimisticLineId(addition),
+					quantity: addition.quantity,
+					attributes: addition.attributes ?? [],
+					sellingPlanAllocation: addition.sellingPlanId ? { sellingPlan: { id: addition.sellingPlanId } } : null,
+					merchandise,
+					cost: {
+						totalAmount: amount,
+						subtotalAmount: amount,
+						amountPerQuantity: amount,
+						compareAtAmountPerQuantity: null
+					}
+				}, ...lines];
+				linesChanged = true;
+			}
+			const addedQuantity = payload.lines.reduce((total, line) => total + line.quantity, 0);
+			const data = setLines({
+				...state.data,
+				totalQuantity: state.data.totalQuantity + addedQuantity
+			}, linesChanged ? lines : getLines(state.data));
+			return {
+				...state,
+				data
+			};
+		},
+		projectPromise: (state, result, payload, addError) => {
+			const currentLines = getLines(state.data);
+			const cart = result.cart ? cartResponseFromStandardEvent(result.cart) : void 0;
+			const serverLines = cart ? getLines(cart) : [];
+			const lineIds = resolveAddLineIds(currentLines, serverLines, payload);
+			if (hasProjectedErrors(result)) addError((current, timestampMs) => projectLineErrors(current, result, lineIds, timestampMs), getAddErrorKeys(payload, lineIds, result));
+			if (!cart) return state;
+			const lines = mergeAddResponseLines(currentLines, serverLines, payload);
+			return {
+				...state,
+				data: reconcileCartLines(state.data, lines)
+			};
+		},
+		getPendingKeys: (state, payload) => {
+			const keys = [];
+			const lines = getLines(state.data);
+			for (const addition of payload.lines) {
+				keys.push(merchandiseKey(addition));
+				const existing = findLineForAddition(lines, addition);
+				if (existing) keys.push(lineKey(existing.id));
+				if (!existing && payload.products.some((product) => product.id === addition.merchandiseId)) keys.push(lineKey(optimisticLineId(addition)));
+			}
+			return keys;
+		},
+		getErrorKeys: (_state, payload) => payload.lines.map(merchandiseKey),
+		removeSupersededPayload: (older, successful) => {
+			const successfulKeys = new Set(successful.lines.map(merchandiseKey));
+			const lines = older.lines.filter((line) => !successfulKeys.has(merchandiseKey(line)));
+			return lines.length > 0 ? {
+				...older,
+				lines
+			} : void 0;
+		}
+	},
+	change_line_quantity: {
+		payload: {},
+		transport: (payload, signal, updateCart) => updateCart({ lines: [{
+			id: payload.lineId,
+			quantity: payload.quantity
+		}] }, { signal }),
+		projectPayload: (state, payload) => {
+			const previous = getLines(state.data);
+			if (!previous.find((line) => line.id === payload.lineId)) return state;
+			const lines = payload.quantity === 0 ? previous.filter((line) => line.id !== payload.lineId) : previous.map((line) => line.id === payload.lineId ? {
+				...line,
+				quantity: payload.quantity
+			} : line);
+			return {
+				...state,
+				data: reconcileCartLines(state.data, lines)
+			};
+		},
+		projectPromise: (state, result, payload, addError) => {
+			if (hasProjectedErrors(result)) addError((current, timestampMs) => projectLineErrors(current, result, [payload.lineId], timestampMs));
+			if (!result.cart) return state;
+			const serverLines = getLines(cartResponseFromStandardEvent(result.cart));
+			const matching = serverLines.find((line) => line.id === payload.lineId);
+			const previous = getLines(state.data);
+			let lines = previous.filter((line) => line.id !== payload.lineId);
+			if (matching) {
+				const prior = previous.find((line) => line.id === payload.lineId);
+				lines = previous.map((line) => line.id === payload.lineId ? mergeServerLine(prior, matching) : line);
+			} else if (payload.quantity > 0 && previous.length === 1 && serverLines.length === 1) lines = [mergeServerLine(previous[0], serverLines[0])];
+			return {
+				...state,
+				data: reconcileCartLines(state.data, lines)
+			};
+		},
+		getSignalKeys: (_state, payload) => lineKey(payload.lineId)
+	},
+	set_discount_codes: {
+		payload: {},
+		transport: (payload, signal, updateCart) => updateCart({ discountCodes: payload.discountCodes }, { signal }),
+		projectPayload: (state, payload) => {
+			const discountCodes = payload.discountCodes.map((code) => {
+				return {
+					code,
+					applicable: state.data.discountCodes.find((discount) => discount.code === code)?.applicable ?? false
+				};
+			});
+			return {
+				...state,
+				data: {
+					...state.data,
+					discountCodes
+				}
+			};
+		},
+		projectPromise: (state, result, payload, addError, options) => {
+			const resolvedCodes = result.cart ? cartResponseFromStandardEvent(result.cart).discountCodes : void 0;
+			if (hasProjectedErrors(result)) addError((current, timestampMs) => projectDiscountErrors(current, result, payload.discountCodes, timestampMs, resolvedCodes));
+			if (!result.cart) return state;
+			const cart = cartResponseFromStandardEvent(result.cart);
+			if (options.mergeServerCart) return {
+				...state,
+				data: mergeAuthoritativeCartData(state.data, cart)
+			};
+			return {
+				...state,
+				data: {
+					...state.data,
+					discountCodes: cart.discountCodes
+				}
+			};
+		},
+		getSignalKeys: () => DISCOUNT_CODES_KEY,
+		getPendingKeys: (state, payload) => {
+			const current = new Set(state.data.discountCodes.map((discount) => discount.code));
+			const next = new Set(payload.discountCodes);
+			return [...new Set([...current, ...next])].filter((code) => current.has(code) !== next.has(code)).map((code) => `${DISCOUNT_KEY_PREFIX}${code}`);
+		}
+	},
+	set_note: {
+		payload: {},
+		transport: (payload, signal, updateCart) => updateCart({ note: payload.note }, { signal }),
+		projectPayload: (state, payload) => ({
+			...state,
+			data: {
+				...state.data,
+				note: payload.note
+			}
+		}),
+		projectPromise: (state, result, payload, addError) => {
+			if (hasProjectedErrors(result)) addError((current, timestampMs) => projectNoteErrors(current, result, timestampMs));
+			if (!result.cart) return state;
+			return {
+				...state,
+				data: {
+					...state.data,
+					note: payload.note
+				}
+			};
+		},
+		getSignalKeys: () => NOTE_KEY
+	},
+	set_attributes: {
+		payload: {},
+		transport: (payload, signal, updateCart) => updateCart({ attributes: payload.attributes }, { signal }),
+		projectPayload: (state, payload) => ({
+			...state,
+			data: {
+				...state.data,
+				attributes: payload.attributes
+			}
+		}),
+		projectPromise: (state, result, payload, addError) => {
+			if (hasProjectedErrors(result)) addError((current, timestampMs) => projectAttributeErrors(current, result, payload.attributes, timestampMs));
+			if (!result.cart || (result.userErrors?.length ?? 0) > 0) return state;
+			return {
+				...state,
+				data: {
+					...state.data,
+					attributes: payload.attributes
+				}
+			};
+		},
+		getSignalKeys: () => ATTRIBUTES_KEY
+	}
+});
+function getTransactionProjectionKeys(definition, state, payload, signalKeys) {
+	return {
+		pendingKeys: normalizeKeys(definition.getPendingKeys?.(state, payload) ?? signalKeys),
+		errorKeys: normalizeKeys(definition.getErrorKeys?.(state, payload) ?? signalKeys)
+	};
+}
+function resolveTransactionIdentity(store, definition, payload, reservation, identity) {
+	const state = store.observable.state;
+	if (identity) {
+		const projectedKeys = getTransactionProjectionKeys(definition, state, payload, identity.signalKeys);
+		const pendingKeys = identity.pendingKeys ?? projectedKeys.pendingKeys;
+		const errorKeys = identity.errorKeys ?? projectedKeys.errorKeys;
+		return {
+			...identity,
+			pendingKeys,
+			errorKeys
+		};
+	}
+	if (reservation) {
+		const id = store.nextTransactionId++;
+		return {
+			...reservation,
+			id,
+			sequence: id,
+			generation: store.generation,
+			requiresRevalidation: false
+		};
+	}
+	const signalKeys = normalizeKeys(definition.getSignalKeys?.(state, payload));
+	const { pendingKeys, errorKeys } = getTransactionProjectionKeys(definition, state, payload, signalKeys);
+	const id = store.nextTransactionId++;
+	return {
+		id,
+		sequence: id,
+		generation: store.generation,
+		owner: createOwner(store, signalKeys),
+		signalKeys,
+		pendingKeys,
+		errorKeys,
+		requiresRevalidation: false
+	};
+}
+function createPendingTransaction(store, type, definition, payload, promise, reservation, identity) {
+	const { id, sequence, generation, owner, signalKeys, pendingKeys, errorKeys, requiresRevalidation } = resolveTransactionIdentity(store, definition, payload, reservation, identity);
+	const transaction = {
+		id,
+		sequence,
+		generation,
+		type,
+		payload,
+		signalKeys,
+		pendingKeys,
+		errorKeys,
+		requiresRevalidation,
+		owner,
+		promise,
+		projectPayload: (current) => definition.projectPayload(current, payload),
+		projectPromise: (current, result, addError) => definition.projectPromise(current, result, payload, addError, { mergeServerCart: !transaction.requiresRevalidation }),
+		trimAfter: (successful) => trimPendingTransaction(store, type, definition, payload, promise, {
+			id,
+			sequence,
+			generation,
+			owner,
+			signalKeys,
+			pendingKeys,
+			errorKeys,
+			requiresRevalidation: transaction.requiresRevalidation
+		}, successful)
+	};
+	return transaction;
+}
+function trimPendingTransaction(store, type, definition, payload, promise, identity, successful) {
+	let remaining = payload;
+	let nextIdentity = identity;
+	if (successful.type === type && definition.removeSupersededPayload) {
+		const trimmed = definition.removeSupersededPayload(payload, successful.payload);
+		if (!trimmed) return void 0;
+		remaining = trimmed;
+		nextIdentity = {
+			...identity,
+			pendingKeys: void 0,
+			errorKeys: void 0
+		};
+	}
+	return createPendingTransaction(store, type, definition, remaining, promise, void 0, nextIdentity);
+}
+function addSnapshotFields(state, result) {
+	if (!result.cart) return state;
+	const cart = cartResponseFromStandardEvent(result.cart);
+	return {
+		...state,
+		data: {
+			...state.data,
+			id: cart.id,
+			checkoutUrl: cart.checkoutUrl ?? state.data.checkoutUrl,
+			updatedAt: cart.updatedAt ?? state.data.updatedAt,
+			totalQuantity: cart.totalQuantity,
+			cost: cart.cost
+		}
+	};
+}
+function addSnapshotIdentity(state, result) {
+	if (!result.cart || state.data.id) return state;
+	const cart = cartResponseFromStandardEvent(result.cart);
+	return {
+		...state,
+		data: {
+			...state.data,
+			id: cart.id
+		}
+	};
+}
+function removeTransaction(store, transactionId) {
+	const index = store.transactions.findIndex((transaction) => transaction.id === transactionId);
+	if (index === -1) return null;
+	const [transaction] = store.transactions.splice(index, 1);
+	return transaction;
+}
+function trimOlderRelativeTransactions(store, successful) {
+	store.transactions = store.transactions.flatMap((transaction) => {
+		if (transaction.sequence >= successful.sequence) return [transaction];
+		const trimmed = transaction.trimAfter(successful);
+		return trimmed ? [trimmed] : [];
+	});
+}
+function fulfillTransaction(store, transactionId, result) {
+	const transaction = store.transactions.find((candidate) => candidate.id === transactionId);
+	if (!transaction || transaction.generation !== store.generation) return;
+	store.observedPromises.delete(transaction.promise);
+	if (!ownsSignalKeys(store, transaction)) {
+		removeTransaction(store, transactionId);
+		publishVisibleState(store);
+		revalidateCartWhenIdle(store);
+		return;
+	}
+	store.settled = transaction.projectPromise(store.settled, result, (projector, keys) => addProjectedError(store, keys ?? transaction.errorKeys, projector));
+	store.settled = addSnapshotIdentity(store.settled, result);
+	if (result.cart && !transaction.requiresRevalidation && transaction.sequence >= store.lastSnapshotSequence) {
+		store.settled = addSnapshotFields(store.settled, result);
+		store.lastSnapshotSequence = transaction.sequence;
+	}
+	removeTransaction(store, transactionId);
+	if (result.cart) trimOlderRelativeTransactions(store, transaction);
+	releaseSignalKeys(store, transaction);
+	publishVisibleState(store);
+	revalidateCartWhenIdle(store);
+}
+function rejectedResult(failure) {
+	return {
+		cart: null,
+		...failure
+	};
+}
+function rejectTransaction(store, transactionId, error) {
+	const transaction = store.transactions.find((candidate) => candidate.id === transactionId);
+	if (!transaction || transaction.generation !== store.generation) return;
+	store.observedPromises.delete(transaction.promise);
+	const owned = ownsSignalKeys(store, transaction);
+	removeTransaction(store, transactionId);
+	releaseSignalKeys(store, transaction);
+	if (owned) {
+		const failure = extractCartActionFailure(error);
+		if (failure) transaction.projectPromise(store.settled, rejectedResult(failure), (projector, keys) => addProjectedError(store, keys ?? transaction.errorKeys, projector));
+		if (!failure && !isAbortError(error)) addProjectedError(store, transaction.errorKeys, (state, timestampMs) => writeNetworkError(state, error, timestampMs));
+	}
+	publishVisibleState(store);
+	revalidateCartWhenIdle(store);
+}
+function enqueueTransaction(store, type, payload, promise, reservedTransaction, eventToken) {
+	const expectedEventIndex = store.expectedEvents.findIndex((expected) => expected.token === eventToken);
+	if (expectedEventIndex !== -1) {
+		store.expectedEvents.splice(expectedEventIndex, 1);
+		return;
+	}
+	if (store.observedPromises.has(promise)) return;
+	store.observedPromises.add(promise);
+	const releaseObservedPromise = () => {
+		store.observedPromises.delete(promise);
+	};
+	promise.then(releaseObservedPromise, releaseObservedPromise);
+	const activeReservation = store.reservation?.type === type ? store.reservation : void 0;
+	const reservation = reservedTransaction ?? activeReservation;
+	if (reservation) reservation.consumed = true;
+	const transaction = createPendingTransaction(store, type, getTransactionDefinition(type), reservation ? reservation.payload : payload, promise, reservation);
+	store.mutationRevision += 1;
+	markOverlappingTransactionForRevalidation(store, transaction);
+	clearProjectedErrors(store, transaction.errorKeys);
+	store.transactions.push(transaction);
+	if (!reservation) observeMutationTransport(store, promise);
+	publishVisibleState(store);
+	promise.then((result) => fulfillTransaction(store, transaction.id, result), (error) => rejectTransaction(store, transaction.id, error));
+}
+function markOverlappingTransactionForRevalidation(store, transaction) {
+	if (store.transactions.length === 0 && !store.revalidation.active && store.activeMutationTransports.size === 0) return;
+	transaction.requiresRevalidation = true;
+	for (const pending of store.transactions) pending.requiresRevalidation = true;
+	requestCartRevalidation(store);
+}
+function requestCartRevalidation(store) {
+	store.revalidation.requested = true;
+	store.revalidation.visible = true;
+	store.revalidation.active?.controller.abort();
+}
+function observeMutationTransport(store, promise) {
+	if (store.activeMutationTransports.has(promise)) return;
+	store.activeMutationTransports.add(promise);
+	const releaseTransport = () => {
+		store.activeMutationTransports.delete(promise);
+		revalidateCartWhenIdle(store);
+	};
+	promise.then(releaseTransport, releaseTransport);
+}
+function createTransactionEventToken() {
+	return crypto.randomUUID();
+}
+function withTransactionEventToken(updateCart, token) {
+	return (payload, options) => updateCart(payload, {
+		...options,
+		event: {
+			...options?.event,
+			detail: {
+				...options?.event?.detail,
+				[TRANSACTION_EVENT_TOKEN_KEY]: token
+			}
+		}
+	});
+}
+function getTransactionEventToken(detail) {
+	const token = detail?.[TRANSACTION_EVENT_TOKEN_KEY];
+	return typeof token === "string" ? token : void 0;
+}
+function reserveTransaction(store, type, payload) {
+	const definition = getTransactionDefinition(type);
+	const state = store.observable.state;
+	const signalKeys = normalizeKeys(definition.getSignalKeys?.(state, payload));
+	const pendingKeys = normalizeKeys(definition.getPendingKeys?.(state, payload) ?? signalKeys);
+	const errorKeys = normalizeKeys(definition.getErrorKeys?.(state, payload) ?? signalKeys);
+	clearProjectedErrors(store, errorKeys);
+	return {
+		type,
+		payload,
+		signalKeys,
+		pendingKeys,
+		errorKeys,
+		owner: createOwner(store, signalKeys),
+		consumed: false
+	};
+}
+function createTransactionSignal(store, reservation) {
+	const signals = [store.lifecycleController.signal, AbortSignal.timeout(STANDARD_ACTION_TIMEOUT_IN_MS)];
+	if (reservation.owner) signals.push(reservation.owner.controller.signal);
+	return AbortSignal.any(signals);
+}
+async function dispatchTransaction(store, type, payload) {
+	if (type === "add_to_cart" && !store.observable.state.data.id) return dispatchInitialCartAdd(store, payload);
+	return dispatchTransactionNow(store, type, payload);
+}
+async function dispatchTransactionNow(store, type, payload) {
+	const generation = store.generation;
+	const { updateCart } = await getShopifyStandardActions();
+	if (generation !== store.generation) return;
+	const reservation = reserveTransaction(store, type, payload);
+	store.reservation = reservation;
+	const signal = createTransactionSignal(store, reservation);
+	const eventToken = createTransactionEventToken();
+	const correlatedUpdateCart = withTransactionEventToken(updateCart, eventToken);
+	let promise;
+	try {
+		promise = getTransactionDefinition(type).transport(payload, signal, correlatedUpdateCart);
+	} finally {
+		store.reservation = null;
+	}
+	if (!reservation.consumed) {
+		enqueueTransaction(store, type, payload, promise, reservation);
+		store.expectedEvents.push({ token: eventToken });
+	}
+	observeMutationTransport(store, promise);
+	try {
+		await promise;
+	} catch (error) {
+		if (isAbortError(error)) return;
+		throw error;
+	}
+}
+function createDeferredCartMutation() {
+	let resolveMutation;
+	let rejectMutation;
+	return {
+		promise: new Promise((resolve, reject) => {
+			resolveMutation = resolve;
+			rejectMutation = reject;
+		}),
+		resolve: (result) => resolveMutation?.(result),
+		reject: (error) => rejectMutation?.(error)
+	};
+}
+function startQueuedInitialAdd(store, queued, cartId) {
+	if (queued.generation !== store.generation || queued.signal.aborted) {
+		queued.deferred.reject(new DOMException("The operation was aborted.", "AbortError"));
+		return;
+	}
+	getShopifyStandardActions().then(({ updateCart }) => {
+		if (queued.generation !== store.generation || queued.signal.aborted) {
+			queued.deferred.reject(new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
+		const eventToken = createTransactionEventToken();
+		const expectedEvent = { token: eventToken };
+		store.expectedEvents.push(expectedEvent);
+		let transport;
+		try {
+			transport = transportAddToCart(queued.payload, queued.signal, withTransactionEventToken(updateCart, eventToken), cartId);
+		} catch (error) {
+			const expectedIndex = store.expectedEvents.indexOf(expectedEvent);
+			if (expectedIndex !== -1) store.expectedEvents.splice(expectedIndex, 1);
+			queued.deferred.reject(error);
+			return;
+		}
+		observeMutationTransport(store, transport);
+		transport.then(queued.deferred.resolve, queued.deferred.reject);
+	}, queued.deferred.reject);
+}
+function releaseQueuedInitialAdds(store) {
+	const gate = store.identityTransportGate;
+	if (gate.active || gate.waiting.length === 0) return;
+	const cartId = store.settled.data.id;
+	if (cartId) {
+		const waiting = gate.waiting.splice(0);
+		for (const queued of waiting) startQueuedInitialAdd(store, queued, cartId);
+		return;
+	}
+	const queued = gate.waiting.shift();
+	if (!queued) return;
+	gate.active = queued;
+	const releaseNext = () => {
+		if (gate.active !== queued) return;
+		gate.active = null;
+		releaseQueuedInitialAdds(store);
+	};
+	queued.deferred.promise.then(releaseNext, releaseNext);
+	startQueuedInitialAdd(store, queued, store.settled.data.id ?? void 0);
+}
+async function dispatchInitialCartAdd(store, payload) {
+	const gate = store.identityTransportGate;
+	const deferred = createDeferredCartMutation();
+	const reservation = reserveTransaction(store, "add_to_cart", payload);
+	const signal = createTransactionSignal(store, reservation);
+	const queued = {
+		deferred,
+		generation: store.generation,
+		payload,
+		reservation,
+		signal
+	};
+	enqueueTransaction(store, "add_to_cart", payload, deferred.promise, reservation);
+	gate.waiting.push(queued);
+	releaseQueuedInitialAdds(store);
+	signal.addEventListener("abort", () => {
+		const index = gate.waiting.indexOf(queued);
+		if (index === -1) return;
+		gate.waiting.splice(index, 1);
+		deferred.reject(new DOMException("The operation was aborted.", "AbortError"));
+	}, { once: true });
+	try {
+		await deferred.promise;
+	} catch (error) {
+		if (isAbortError(error)) return;
+		throw error;
+	}
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function payloadFromAddEvent(event) {
+	return {
+		lines: event.lines,
+		products: extractProductDetails(event.detail),
+		...event.detail ? { eventDetail: event.detail } : {}
+	};
+}
+function handleLinesEvent(store, event) {
+	const eventToken = getTransactionEventToken(event.detail);
+	if (event.action === "add") {
+		enqueueTransaction(store, "add_to_cart", payloadFromAddEvent(event), event.promise, void 0, eventToken);
+		return;
+	}
+	if (event.lines.length !== 1) return;
+	const line = event.lines[0];
+	enqueueTransaction(store, "change_line_quantity", {
+		lineId: line.id,
+		quantity: line.quantity
+	}, event.promise, void 0, eventToken);
+}
+function handleDiscountEvent(store, event) {
+	enqueueTransaction(store, "set_discount_codes", { discountCodes: event.discountCodes.map((discount) => discount.code) }, event.promise, void 0, getTransactionEventToken(event.detail));
+}
+function handleNoteEvent(store, event) {
+	enqueueTransaction(store, "set_note", { note: event.note }, event.promise, void 0, getTransactionEventToken(event.detail));
+}
+function handleAttributesEvent(store, event) {
+	enqueueTransaction(store, "set_attributes", { attributes: event.attributes }, event.promise, void 0, getTransactionEventToken(event.detail));
+}
+function connectCartStore(store, handlers) {
+	if (typeof document === "undefined") return false;
+	if (store.lifecycleController.signal.aborted) store.lifecycleController = new AbortController();
+	if (store.cartSyncAttached) return true;
+	store.cartSyncAttached = true;
+	connectedCartStores.add(store);
+	attachCartConsentListener();
+	document.addEventListener("shopify:cart:lines-update", handlers.lines);
+	document.addEventListener("shopify:cart:discount-update", handlers.discount);
+	document.addEventListener("shopify:cart:note-update", handlers.note);
+	document.addEventListener("shopify:cart:attributes-update", handlers.attributes);
+	getShopifyStandardActions().catch(() => {});
+	return true;
+}
+function cancelCartRevalidation(store) {
+	store.revalidation.active?.controller.abort();
+	store.revalidation.active = null;
+	store.revalidation.requested = false;
+	store.revalidation.visible = false;
+}
+function clearPendingTransactions(store) {
+	store.generation += 1;
+	store.lifecycleController.abort();
+	store.lifecycleController = new AbortController();
+	for (const owner of new Set(store.keyedOwners.values())) owner.controller.abort();
+	store.keyedOwners.clear();
+	store.transactions = [];
+	store.projectedErrors = [];
+	store.observedPromises.clear();
+	store.activeMutationTransports.clear();
+	store.expectedEvents = [];
+	store.reservation = null;
+	store.identityTransportGate.active = null;
+	for (const queued of store.identityTransportGate.waiting) queued.deferred.reject(new DOMException("The operation was aborted.", "AbortError"));
+	store.identityTransportGate.waiting = [];
+	cancelCartRevalidation(store);
+}
+function destroyCartStore(store, handlers) {
+	clearPendingTransactions(store);
+	if (typeof document !== "undefined" && store.cartSyncAttached) {
+		document.removeEventListener("shopify:cart:lines-update", handlers.lines);
+		document.removeEventListener("shopify:cart:discount-update", handlers.discount);
+		document.removeEventListener("shopify:cart:note-update", handlers.note);
+		document.removeEventListener("shopify:cart:attributes-update", handlers.attributes);
+	}
+	connectedCartStores.delete(store);
+	detachCartConsentListenerIfIdle();
+	store.cartSyncAttached = false;
+	publishVisibleState(store);
+}
+function handleVisitorConsentCollected() {
+	revalidateConnectedCartCheckoutUrls();
+}
+function attachCartConsentListener() {
+	if (cartConsentListenerAttached) return;
+	document.addEventListener(VISITOR_CONSENT_COLLECTED_EVENT, handleVisitorConsentCollected);
+	cartConsentListenerAttached = true;
+}
+function detachCartConsentListenerIfIdle() {
+	if (!cartConsentListenerAttached || connectedCartStores.size > 0) return;
+	document.removeEventListener(VISITOR_CONSENT_COLLECTED_EVENT, handleVisitorConsentCollected);
+	cartConsentListenerAttached = false;
+}
+function createCartObservable(initialState, onReadyPromiseRemoved) {
+	const observable = createObservable(initialState);
+	return {
+		get state() {
+			return observable.state;
+		},
+		subscribe: observable.subscribe,
+		setState(next) {
+			observable.setState((prev) => {
+				const nextState = typeof next === "function" ? next(prev) : next;
+				if (Object.is(nextState, prev)) return prev;
+				if (prev.readyPromise) {
+					onReadyPromiseRemoved();
+					return withoutReadyPromise({
+						...nextState,
+						loading: false
+					});
+				}
+				return withoutReadyPromise(nextState);
+			});
+		},
+		setReadyState(next) {
+			observable.setState(next);
+		},
+		clearReadyState() {
+			observable.setState(withoutReadyPromise(observable.state));
+		}
+	};
+}
+function withoutReadyPromise(state) {
+	if (!state.readyPromise) return state;
+	const nextState = {
+		...state,
+		loading: false
+	};
+	delete nextState.readyPromise;
+	return nextState;
+}
+function invalidateActiveCartLoad(store) {
+	const activeCartLoad = store.activeCartLoad;
+	if (!activeCartLoad) return;
+	store.activeCartLoad = null;
+	activeCartLoad.resolveReadyPromise();
+}
+function hasLocalCartData(state) {
+	return state.data.id !== null || state.data.totalQuantity > EMPTY_QUANTITY || getLines(state.data).length > 0;
+}
+function hydrateCartInStore(store, data) {
+	const current = store.observable.state;
+	invalidateActiveCartLoad(store);
+	if (current.data.id !== null && current.data.id === data.id) {
+		store.observable.clearReadyState();
+		return;
+	}
+	if (store.transactions.length > 0) {
+		store.observable.clearReadyState();
+		return;
+	}
+	cancelCartRevalidation(store);
+	store.settled = createCartState(data);
+	store.projectedErrors = [];
+	publishVisibleState(store);
+}
+function resetCartStore(store) {
+	const hadActiveCartLoad = store.activeCartLoad !== null;
+	const hadActiveRevalidation = store.revalidation.active !== null;
+	const shouldReloadAfterReset = store.cartSyncAttached && !hadActiveRevalidation && (hadActiveCartLoad || hasLocalCartData(store.observable.state));
+	clearPendingTransactions(store);
+	invalidateActiveCartLoad(store);
+	cancelCartRevalidation(store);
+	store.lastSnapshotSequence = 0;
+	store.settled = createEmptyCartState();
+	publishVisibleState(store);
+	if (shouldReloadAfterReset) loadCartInStore(store).catch((error) => log.error("cart reset load failed", { error }));
+}
+function isCurrentCartLoad(store, request) {
+	return store.activeCartLoad === request && store.observable.state === request.state;
+}
+function loadCartInStore(store, cartPromise) {
+	const existing = store.activeCartLoad;
+	if (existing?.state === store.observable.state) return existing.promise;
+	invalidateActiveCartLoad(store);
+	let resolveReadyPromise = NOOP;
+	const readyPromise = new Promise((resolve) => {
+		resolveReadyPromise = resolve;
+	});
+	let request;
+	const state = {
+		...store.observable.state,
+		readyPromise
+	};
+	const promise = Promise.resolve(cartPromise ?? fetchCartData(state.data.id)).then((data) => {
+		if (!isCurrentCartLoad(store, request)) return;
+		if (data) hydrateCartInStore(store, data);
+		if (!data) {
+			store.settled = {
+				...store.settled,
+				loading: false
+			};
+			publishVisibleState(store);
+		}
+	}).catch((error) => {
+		if (isCurrentCartLoad(store, request)) {
+			store.settled = {
+				...store.settled,
+				loading: false
+			};
+			publishVisibleState(store);
+		}
+		throw error;
+	}).finally(() => {
+		if (store.activeCartLoad === request) store.activeCartLoad = null;
+		request.resolveReadyPromise();
+	});
+	request = {
+		state,
+		promise,
+		resolveReadyPromise
+	};
+	store.activeCartLoad = request;
+	store.observable.setReadyState(state);
+	return promise;
+}
+function createCartStore(options = {}) {
+	const initialData = options.initialData;
+	const asyncInitialData = isPromiseLike(initialData);
+	const syncInitialData = initialData !== void 0 && !asyncInitialData;
+	const initialCart = syncInitialData ? initialData.cart : null;
+	const settled = initialCart ? createCartState(initialCart) : syncInitialData ? createEmptyCartState({ loading: false }) : createEmptyCartState();
+	let context = null;
+	const store = {
+		observable: createCartObservable(settled, () => {
+			if (context) invalidateActiveCartLoad(context);
+		}),
+		settled,
+		transactions: [],
+		projectedErrors: [],
+		observedPromises: /* @__PURE__ */ new Set(),
+		activeMutationTransports: /* @__PURE__ */ new Set(),
+		expectedEvents: [],
+		nextTransactionId: 1,
+		generation: 0,
+		lifecycleController: new AbortController(),
+		keyedOwners: /* @__PURE__ */ new Map(),
+		activeCartLoad: null,
+		revalidation: {
+			requested: false,
+			active: null,
+			visible: false
+		},
+		mutationRevision: 0,
+		identityTransportGate: {
+			active: null,
+			waiting: []
+		},
+		cartSyncAttached: false,
+		reservation: null,
+		lastSnapshotSequence: 0
+	};
+	context = store;
+	const handlers = {
+		lines: ((event) => handleLinesEvent(store, event)),
+		discount: ((event) => handleDiscountEvent(store, event)),
+		note: ((event) => handleNoteEvent(store, event)),
+		attributes: ((event) => handleAttributesEvent(store, event))
+	};
+	if (asyncInitialData) loadCartInStore(store, Promise.resolve(initialData).then((data) => data.cart)).catch((error) => log.error("cart initial load failed", { error }));
+	let initialCartLoadStarted = syncInitialData || asyncInitialData;
+	return {
+		connect: () => {
+			if (!connectCartStore(store, handlers) || initialCartLoadStarted) return;
+			initialCartLoadStarted = true;
+			loadCartInStore(store).catch((error) => log.error("cart initial load failed", { error }));
+		},
+		destroy: () => destroyCartStore(store, handlers),
+		hydrate: (data) => hydrateCartInStore(store, data),
+		getState: () => store.observable.state,
+		subscribe: (listener) => store.observable.subscribe(listener),
+		fetch: () => loadCartInStore(store),
+		refresh: () => refreshCartInStore(store),
+		reset: () => resetCartStore(store),
+		handleFormSubmit: (event, eventDetail) => handleFormSubmitInStore(store, handlers, event, eventDetail)
+	};
+}
+const LINE_INTENTS = new Set([
+	"increase",
+	"decrease",
+	"remove",
+	"set"
+]);
+const DISCOUNT_INTENTS = new Set(["discount-apply", "discount-remove"]);
+function requireFormEvent(event) {
+	if (!(event.target instanceof HTMLFormElement)) throw new TypeError(`Expected event.target to be an HTMLFormElement, got ${event.target}`);
+	if (!(event.submitter instanceof HTMLElement)) throw new TypeError(`Expected event.submitter to be an HTMLElement, got ${event.submitter}`);
+	return {
+		form: event.target,
+		submitter: event.submitter
+	};
+}
+function getLineQuantityPayload(state, intent, lineId, formData) {
+	const line = getLines(state.data).find((candidate) => candidate.id === lineId);
+	const currentQuantity = line?.quantity ?? 0;
+	if (intent === "remove") return {
+		lineId,
+		quantity: 0
+	};
+	if (intent === "increase") return {
+		lineId,
+		quantity: currentQuantity + 1
+	};
+	if (intent === "decrease") return {
+		lineId,
+		quantity: Math.max(0, currentQuantity - 1)
+	};
+	const rawQuantity = Number(formData.get("quantity"));
+	const explicitQuantity = Number.isNaN(rawQuantity) ? 1 : rawQuantity;
+	if (explicitQuantity <= 0) return {
+		lineId,
+		quantity: 0
+	};
+	return {
+		lineId,
+		quantity: sanitizeQuantity(explicitQuantity, {
+			min: 1,
+			max: line?.merchandise?.quantityAvailable ?? void 0
+		})
+	};
+}
+function getAddPayload(formData, eventDetail) {
+	const merchandiseId = formData.get("merchandiseId");
+	if (!merchandiseId) throw new Error("Add intent requires a \"merchandiseId\" field.");
+	const rawQuantity = Number.parseInt(formData.get("quantity"), 10);
+	const quantity = Number.isNaN(rawQuantity) ? DEFAULT_ADD_QUANTITY : Math.max(DEFAULT_ADD_QUANTITY, rawQuantity);
+	const sellingPlanId = formData.get("sellingPlanId") || void 0;
+	return {
+		lines: [{
+			merchandiseId,
+			quantity,
+			...sellingPlanId ? { sellingPlanId } : {}
+		}],
+		products: extractProductDetails(eventDetail),
+		...eventDetail ? { eventDetail } : {}
+	};
+}
+function submitLineIntent(store, intent, formData) {
+	const lineId = formData.get("lineId");
+	if (!lineId) throw new Error("Missing \"lineId\" in form data");
+	return dispatchTransaction(store, "change_line_quantity", getLineQuantityPayload(store.observable.state, intent, lineId, formData));
+}
+function submitDiscountIntent(store, intent, formData) {
+	const code = formData.get("discountCode") ?? "";
+	const currentCodes = store.observable.state.data.discountCodes.map((discount) => discount.code);
+	return dispatchTransaction(store, "set_discount_codes", { discountCodes: intent === "discount-apply" ? [...currentCodes, code] : currentCodes.filter((current) => current !== code) });
+}
+async function handleFormSubmitInStore(store, handlers, event, eventDetail) {
+	const { form, submitter } = requireFormEvent(event);
+	connectCartStore(store, handlers);
+	const intent = submitter.getAttribute("value") ?? "";
+	const formData = new FormData(form);
+	if (intent === "add" || !intent && formData.has("merchandiseId")) return dispatchTransaction(store, "add_to_cart", getAddPayload(formData, eventDetail));
+	if (LINE_INTENTS.has(intent)) return submitLineIntent(store, intent, formData);
+	if (DISCOUNT_INTENTS.has(intent)) return submitDiscountIntent(store, intent, formData);
+	if (intent === "note-update") return dispatchTransaction(store, "set_note", { note: formData.get("note") ?? "" });
+	if (intent === "attributes-update") return dispatchTransaction(store, "set_attributes", { attributes: getCartAttributeFormEntries(formData).map(({ key, value }) => ({
+		key,
+		value: String(value)
+	})) });
+	throw new Error(`Unknown cart form intent: "${intent}"`);
+}
+function configureCartEndpoint(endpoint) {
+	if (configuredCartEndpoint === endpoint) return;
+	if (configuredCartEndpoint !== null) log.warn(`configureCartEndpoint called with "${endpoint}" but already configured with "${configuredCartEndpoint}".`);
+	configuredCartEndpoint = endpoint;
+}
+async function postCartUpdateToEndpoint(endpoint, payload, options) {
+	const timeoutSignal = AbortSignal.timeout(STANDARD_ACTION_TIMEOUT_IN_MS);
+	const signal = options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(payload),
+		signal
+	});
+	if (!response.ok) throw new CartNetworkError(response.status);
+	return response.json();
+}
+function configureUpdateCartOnce(actions) {
+	if (hasConfiguredUpdateCart) return;
+	if (actions.updateCart.configure({
+		eventTarget: () => document,
+		handler: (defaultHandler, payload, options) => {
+			if (!configuredCartEndpoint || !payload) return defaultHandler();
+			return postCartUpdateToEndpoint(configuredCartEndpoint, payload, options);
+		}
+	}) === false) throw new Error("Standard Actions updateCart could not be configured.");
+	hasConfiguredUpdateCart = true;
+}
+function hasShopifyStandardActionsScript() {
+	if (typeof document === "undefined") return false;
+	return document.querySelector(`script[src="${SHOPIFY_STOREFRONT_STANDARD_ACTIONS_SCRIPT}"]`) !== null;
+}
+function getShopifyStandardActions() {
+	return standardActionsPromise ??= new Promise((resolve, reject) => {
+		const configure = () => {
+			const actions = typeof window === "undefined" ? void 0 : window.Shopify?.actions;
+			if (actions?.updateCart) {
+				configureUpdateCartOnce(actions);
+				resolve(actions);
+				return;
+			}
+			const message = hasShopifyStandardActionsScript() ? "Standard Actions not available. Ensure the Shopify script tag has loaded before calling cart actions." : `Standard Actions not available. Add ShopifyScripts to your document head or include ${SHOPIFY_STOREFRONT_STANDARD_ACTIONS_SCRIPT} before calling cart actions.`;
+			reject(new Error(message));
+		};
+		if (typeof document !== "undefined" && document.readyState === "loading") {
+			document.addEventListener("DOMContentLoaded", configure, { once: true });
+			return;
+		}
+		configure();
+	}).catch((error) => {
+		standardActionsPromise = null;
+		throw error;
+	});
+}
+function extractNoteFromCart(cart) {
+	return cart.note ?? "";
+}
+async function fetchCart(cartId, callerSignal) {
+	const timeoutSignal = AbortSignal.timeout(STANDARD_ACTION_TIMEOUT_IN_MS);
+	const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+	if (configuredCartEndpoint) {
+		const response = await fetch(configuredCartEndpoint, {
+			cache: "no-store",
+			signal
+		});
+		if (!response.ok) throw new CartNetworkError(response.status);
+		return { cart: (await response.json()).cart };
+	}
+	const { getCart } = await getShopifyStandardActions();
+	if (!getCart) throw new Error("Standard Actions not available. Ensure the Shopify script tag is loaded before calling fetchCart.");
+	return { cart: (await getCart(cartId ? { cartId } : void 0, { signal })).cart };
+}
+function fetchCartData(cartId, signal) {
+	return fetchCart(cartId, signal).then(({ cart }) => cart ? {
+		...cart,
+		checkoutUrl: cart.checkoutUrl ?? null,
+		note: extractNoteFromCart(cart),
+		attributes: cart.attributes ?? []
+	} : null);
+}
+function mergeAuthoritativeCartData(previous, authoritative) {
+	const previousLines = new Map(getLines(previous).map((line) => [line.id, line]));
+	const lines = getLines(authoritative).map((line) => mergeServerLine(previousLines.get(line.id), line));
+	const { checkoutUrl, cost, lines: authoritativeConnection, note, ...authoritativeFields } = authoritative;
+	return {
+		...previous,
+		...authoritativeFields,
+		cost: {
+			...previous.cost,
+			...cost
+		},
+		lines: {
+			...previous.lines,
+			...authoritativeConnection,
+			nodes: lines
+		},
+		...checkoutUrl !== void 0 && { checkoutUrl },
+		...note !== void 0 && { note }
+	};
+}
+function fetchCartRevalidationData(cartId, signal) {
+	return fetchCart(cartId, signal).then(({ cart }) => cart ? cartResponseFromStandardEvent(cart) : null);
+}
+function isCurrentCartRevalidationRequest(store, request) {
+	return !request.controller.signal.aborted && store.revalidation.active === request && store.generation === request.generation && store.mutationRevision === request.mutationRevision && store.transactions.length === 0 && store.settled.data.id === request.cartId;
+}
+function applyCartRevalidation(store, request, cart) {
+	if (!isCurrentCartRevalidationRequest(store, request)) return;
+	if (request.cartId === null) {
+		if (cart) {
+			hydrateCartInStore(store, cart);
+			return;
+		}
+		store.revalidation.visible = false;
+		publishVisibleState(store);
+		return;
+	}
+	if (!cart) throw new Error(CART_REVALIDATION_ERROR_MESSAGE);
+	if (cart.id !== request.cartId) {
+		hydrateCartInStore(store, cart);
+		return;
+	}
+	store.settled = {
+		...store.settled,
+		data: mergeAuthoritativeCartData(store.settled.data, cart)
+	};
+	store.revalidation.visible = false;
+	publishVisibleState(store);
+}
+function refreshCartInStore(store) {
+	const activeCartLoad = store.activeCartLoad;
+	if (activeCartLoad) {
+		const runAfterLoad = () => refreshCartInStore(store);
+		activeCartLoad.promise.then(runAfterLoad, runAfterLoad);
+		return;
+	}
+	requestCartRevalidation(store);
+	publishVisibleState(store);
+	revalidateCartWhenIdle(store);
+}
+function revalidateCartWhenIdle(store) {
+	if (!store.revalidation.requested || store.revalidation.active || store.transactions.length > 0 || store.activeMutationTransports.size > 0) return;
+	store.revalidation.requested = false;
+	clearProjectedErrors(store, [REVALIDATION_ERROR_KEY]);
+	publishVisibleState(store);
+	const cartId = store.settled.data.id;
+	const controller = new AbortController();
+	let request;
+	const promise = (cartId ? fetchCartRevalidationData(cartId, controller.signal) : fetchCartData(null, controller.signal)).then((cart) => applyCartRevalidation(store, request, cart)).catch((error) => {
+		if (isAbortError(error) || !isCurrentCartRevalidationRequest(store, request)) return;
+		store.revalidation.visible = false;
+		addProjectedError(store, [REVALIDATION_ERROR_KEY], (state, timestampMs) => writeNetworkError(state, new Error(CART_REVALIDATION_ERROR_MESSAGE), timestampMs));
+		publishVisibleState(store);
+	}).finally(() => {
+		if (store.revalidation.active === request) store.revalidation.active = null;
+		revalidateCartWhenIdle(store);
+	});
+	request = {
+		cartId,
+		controller,
+		generation: store.generation,
+		mutationRevision: store.mutationRevision,
+		promise
+	};
+	store.revalidation.active = request;
+}
+async function refreshCheckoutUrl(store) {
+	const { cart } = await fetchCart(store.observable.state.data.id);
+	const current = store.observable.state;
+	if (!cart || current.data.id && current.data.id !== cart.id) return;
+	const checkoutUrl = cart.checkoutUrl ?? null;
+	if (current.data.checkoutUrl === checkoutUrl) return;
+	store.settled = {
+		...store.settled,
+		data: {
+			...store.settled.data,
+			checkoutUrl
+		}
+	};
+	publishVisibleState(store);
+}
+/** @internal */
+function revalidateConnectedCartCheckoutUrls() {
+	if (typeof window === "undefined") return;
+	for (const store of connectedCartStores) {
+		const state = store.observable.state;
+		if (!state.data.checkoutUrl || state.data.totalQuantity === 0) continue;
+		refreshCheckoutUrl(store).catch(() => {});
+	}
+}
+
+//#endregion
+export { CartNetworkError, STANDARD_ACTION_TIMEOUT_IN_MS, configureCartEndpoint, createCartStore };
+//# sourceMappingURL=cart.mjs.map