@revenexx/cover 0.1.0

package/app/composables/useCartStore.ts

@@ -0,0 +1,837 @@
+import { defineStore, skipHydrate } from "pinia";
+
+import { getPriceWithOptionalTax } from "../composables/useProducts";
+import type { Requisition } from "../interfaces/b2b";
+import type { CartItem } from "../interfaces/cart-item";
+import type { CartRequisitionMeta, PersistedCart } from "../interfaces/persisted-cart";
+
+/** A stashed (non-active) named cart — the multiple-carts feature. */
+export interface NamedCart {
+	id: string;
+	name: string;
+	items: CartItem[];
+	requisitions: CartRequisitionMeta[];
+	updatedAt: string;
+}
+
+/** Summary row for cart listings (switcher, account page). */
+export interface CartSummaryEntry {
+	id: string;
+	name: string;
+	itemCount: number;
+	positions: number;
+	value: number;
+	updatedAt: string;
+	active: boolean;
+}
+
+const MULTI_CART_STORAGE = "cover-carts";
+const ADD_PREF_STORAGE = "cover-cart-add-pref";
+
+export const useCartStore = defineStore("cart", () => {
+	const { public: { cartInactivityTtl, taxIncludedPrices } } = useRuntimeConfig();
+	const items = skipHydrate(ref<CartItem[]>([]));
+	/** Meta of requisitions currently loaded into the cart. */
+	const requisitions = skipHydrate(ref<CartRequisitionMeta[]>([]));
+	const isOpen = ref(false);
+
+	/* ---- live carts (carts app via the BFF) ----------------------------- */
+	// The dev-mode cookie is the demo/live switch — readable client-side by
+	// design. In live mode the carts app is the source of truth: the active
+	// cart syncs through /api/cart, the multi-cart list through /api/carts.
+	const devModeCookie = useCookie<string | null>("cover-dev-mode", { default: () => null, watch: true });
+	const liveCarts = computed(() => {
+		const raw = devModeCookie.value;
+		if (!raw) {
+			return false;
+		}
+		try {
+			const parsed = (typeof raw === "string" ? JSON.parse(raw) : raw) as { mode?: string; overrides?: Record<string, string> };
+			const override = parsed.overrides?.cartService;
+			if (override) {
+				return override === "api";
+			}
+			return parsed.mode === "live";
+		}
+		catch {
+			return false;
+		}
+	});
+const SERVER_CART_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+	/** Server-side cart list (live mode) — feeds switcher + account page. */
+	const serverCarts = skipHydrate(ref<CartSummaryEntry[]>([]));
+
+	const refreshCartList = async () => {
+		if (!import.meta.client || !liveCarts.value) {
+			return;
+		}
+		try {
+			const data = await $fetch<{ carts: CartSummaryEntry[]; activeCartId: string | null; managed: boolean }>("/api/carts");
+			if (data.managed) {
+				serverCarts.value = data.carts;
+				const active = data.carts.find(c => c.active);
+				if (active) {
+					activeCartId.value = active.id;
+					activeCartName.value = active.name;
+				}
+			}
+		}
+		catch { /* best-effort */ }
+	};
+
+	/* ---- multiple carts (feature-flagged via org settings) ------------- */
+	const activeCartId = skipHydrate(ref("default"));
+	const activeCartName = skipHydrate(ref("Mein Warenkorb"));
+	/** All carts EXCEPT the active one — `items`/`requisitions` stay the active cart. */
+	const extraCarts = skipHydrate(ref<NamedCart[]>([]));
+	/** Skip the target-cart dialog and always add to the active cart. */
+	const alwaysActiveCart = skipHydrate(ref(false));
+	/** Set by the modal host when the org flag is on and the dialog wanted. */
+	const interceptAdds = ref(false);
+	/** Last single-add waiting for a target-cart decision (drives the modal). */
+	const pendingAdd = ref<{ lineKey: string; name: string } | null>(null);
+
+	let lineCounter = 0;
+	const nextLineKey = (prefix: string): string => `${prefix}-${Date.now().toString(36)}-${++lineCounter}`;
+
+	const resolveUnitPrice = (item: CartItem): number => {
+		if (!item.priceTiers?.length) {
+			return item.price;
+		}
+
+		let effectivePrice = item.price;
+		for (const tier of item.priceTiers) {
+			if (item.quantity >= tier.minQuantity) {
+				effectivePrice = tier.unitPrice;
+			}
+			else {
+				break;
+			}
+		}
+		return effectivePrice;
+	};
+
+	const effectivePrices = computed(() => {
+		const map = new Map<string, number>();
+		for (const item of items.value) {
+			map.set(item.id, resolveUnitPrice(item));
+		}
+		return map;
+	});
+
+	const itemCount = computed(() => items.value.reduce((sum, i) => sum + i.quantity, 0));
+	const subtotal = computed(() =>
+		items.value.reduce((sum, i) => sum + resolveUnitPrice(i) * i.quantity, 0),
+	);
+	const isEmpty = computed(() => items.value.length === 0);
+
+	const TAX_RATE = 0.19;
+
+	const normalizeTaxRate = (taxRate: number): number => {
+		const normalizedRate = taxRate > 1 ? taxRate / 100 : taxRate;
+
+		if (!Number.isFinite(normalizedRate) || normalizedRate < 0) {
+			return TAX_RATE;
+		}
+
+		return normalizedRate;
+	};
+
+	const taxByRate = computed(() => {
+		const grouped = new Map<number, number>();
+
+		for (const item of items.value) {
+			const taxRateRaw
+				= typeof item.taxRate === "number" && Number.isFinite(item.taxRate)
+					? item.taxRate
+					: TAX_RATE;
+			const taxRate = normalizeTaxRate(taxRateRaw);
+			const itemTax = resolveUnitPrice(item) * item.quantity * taxRate;
+
+			grouped.set(taxRate, (grouped.get(taxRate) ?? 0) + itemTax);
+		}
+
+		return [...grouped.entries()]
+			.map(([rate, amount]) => ({ rate, amount }))
+			.sort((a, b) => a.rate - b.rate);
+	});
+
+	const visibleTaxRows = computed(() =>
+		taxByRate.value.filter(row => row.rate > 0),
+	);
+	const tax = computed(() =>
+		taxByRate.value.reduce((sum, row) => sum + row.amount, 0),
+	);
+	const subtotalDisplay = computed(() =>
+		items.value.reduce((sum, item) => {
+			const unitPrice = resolveUnitPrice(item);
+			if (!taxIncludedPrices) {
+				return sum + unitPrice * item.quantity;
+			}
+
+			const taxRateRaw
+				= typeof item.taxRate === "number" && Number.isFinite(item.taxRate)
+					? item.taxRate
+					: TAX_RATE;
+			const unitPriceWithTax = getPriceWithOptionalTax(unitPrice, taxRateRaw, true);
+
+			return sum + unitPriceWithTax * item.quantity;
+		}, 0),
+	);
+	const total = computed(() => subtotal.value + tax.value);
+
+	const addItem = (
+		product: Omit<CartItem, "quantity">,
+		options?: { chooseTarget?: boolean },
+	): boolean => {
+		const existing = items.value.find(i => i.id === product.id && !i.requisitionId);
+		let addedKey: string | null = null;
+		if (existing) {
+			const maxOrderQuantity = existing.maxOrderQuantity ?? product.maxOrderQuantity;
+			if (typeof maxOrderQuantity === "number" && existing.quantity >= maxOrderQuantity) {
+				return false;
+			}
+			if (typeof existing.maxOrderQuantity !== "number" && typeof product.maxOrderQuantity === "number") {
+				existing.maxOrderQuantity = product.maxOrderQuantity;
+			}
+			existing.quantity++;
+			addedKey = existing.lineKey ?? null;
+		}
+		else {
+			if (typeof product.maxOrderQuantity === "number" && product.maxOrderQuantity < 1) {
+				return false;
+			}
+			const lineKey = nextLineKey("li");
+			items.value.push({ ...product, lineKey, quantity: 1 });
+			addedKey = lineKey;
+		}
+		if (options?.chooseTarget && interceptAdds.value && addedKey) {
+			pendingAdd.value = { lineKey: addedKey, name: product.name };
+		}
+		return true;
+	};
+
+	const removeItem = (id: string) => {
+		items.value = items.value.filter(i => i.id !== id);
+	};
+
+	const updateQuantity = (id: string, quantity: number) => {
+		if (quantity <= 0) {
+			removeItem(id);
+			return;
+		}
+		const item = items.value.find(i => i.id === id);
+		if (typeof item?.maxOrderQuantity === "number" && quantity > item.maxOrderQuantity) {
+			item.quantity = item.maxOrderQuantity;
+			return;
+		}
+		if (item) {
+			item.quantity = quantity;
+		}
+	};
+
+	const clearCart = () => {
+		items.value = [];
+		requisitions.value = [];
+	};
+
+	const keyOf = (item: CartItem): string => item.lineKey ?? `id-${item.id}`;
+
+	const findByKey = (lineKey: string): CartItem | undefined =>
+		items.value.find(i => keyOf(i) === lineKey);
+
+	const removeByKeys = (lineKeys: string[]) => {
+		const keys = new Set(lineKeys);
+		items.value = items.value.filter(i => !keys.has(keyOf(i)));
+		pruneEmptyRequisitions();
+	};
+
+	const updateQuantityByKey = (lineKey: string, quantity: number) => {
+		const item = findByKey(lineKey);
+		if (!item) {
+			return;
+		}
+		if (quantity <= 0) {
+			removeByKeys([lineKey]);
+			return;
+		}
+		if (typeof item.maxOrderQuantity === "number" && quantity > item.maxOrderQuantity) {
+			item.quantity = item.maxOrderQuantity;
+			return;
+		}
+		item.quantity = quantity;
+	};
+
+	const setCostCenter = (lineKeys: string[], costCenterId: string | undefined) => {
+		const keys = new Set(lineKeys);
+		for (const item of items.value) {
+			if (keys.has(keyOf(item))) {
+				item.costCenterId = costCenterId;
+			}
+		}
+	};
+
+	const setPositionDetails = (
+		lineKeys: string[],
+		details: { positionTexts?: string[]; customSku?: string },
+	) => {
+		const keys = new Set(lineKeys);
+		for (const item of items.value) {
+			if (!keys.has(keyOf(item))) {
+				continue;
+			}
+			if (details.positionTexts !== undefined) {
+				const texts = details.positionTexts.map(t => t.trim());
+				while (texts.length && texts[texts.length - 1] === "") {
+					texts.pop();
+				}
+				item.positionTexts = texts.length ? texts : undefined;
+			}
+			if (details.customSku !== undefined) {
+				item.customSku = details.customSku.trim() || undefined;
+			}
+		}
+	};
+
+	/**
+	 * Reorders a position within its scope (free items or one requisition) —
+	 * requisition positions never leave their group (spec).
+	 */
+	const moveWithinScope = (scope: string | undefined, fromIndex: number, toIndex: number) => {
+		const scopeIndices = items.value
+			.map((item, index) => ({ item, index }))
+			.filter(({ item }) => item.requisitionId === scope)
+			.map(({ index }) => index);
+		const from = scopeIndices[fromIndex];
+		const to = scopeIndices[toIndex];
+		if (from === undefined || to === undefined || from === to) {
+			return;
+		}
+		const next = [...items.value];
+		const [moved] = next.splice(from, 1);
+		next.splice(to, 0, moved!);
+		items.value = next;
+	};
+
+	/**
+	 * Loads a requisition into the cart. Per spec, requisitions may only be
+	 * combined when their delivery addresses match (company, street, postal
+	 * code, city, country). Returns false when the validation fails.
+	 */
+	const addRequisition = (requisition: Requisition): boolean => {
+		if (requisitions.value.some(r => r.id === requisition.id)) {
+			return false;
+		}
+		const addressKey = (a?: Requisition["deliveryAddress"]) =>
+			a ? [a.company, a.street, a.postalCode, a.city, a.country].join("|") : "";
+		const existingWithAddress = requisitions.value.find(r => r.deliveryAddress);
+		if (
+			existingWithAddress
+			&& requisition.deliveryAddress
+			&& addressKey(existingWithAddress.deliveryAddress) !== addressKey(requisition.deliveryAddress)
+		) {
+			return false;
+		}
+		const { items: reqItems, ...meta } = requisition;
+		requisitions.value = [...requisitions.value, meta];
+		items.value = [
+			...items.value,
+			...reqItems.map(item => ({
+				...item,
+				image: item.image ?? "",
+				lineKey: nextLineKey(requisition.id),
+				requisitionId: requisition.id,
+			})),
+		];
+		return true;
+	};
+
+	/** Unloads a requisition (meta + its positions) from the cart. */
+	const removeRequisition = (requisitionId: string) => {
+		requisitions.value = requisitions.value.filter(r => r.id !== requisitionId);
+		items.value = items.value.filter(i => i.requisitionId !== requisitionId);
+	};
+
+	const pruneEmptyRequisitions = () => {
+		requisitions.value = requisitions.value.filter(r =>
+			items.value.some(i => i.requisitionId === r.id),
+		);
+	};
+
+	const syncToServer = async () => {
+		if (!import.meta.client) {
+			return;
+		}
+		try {
+			await $fetch("/api/cart/sync", {
+				method: "POST",
+				body: { items: items.value },
+			});
+		}
+		catch { /* local cart is the source of truth; server sync is best-effort */ }
+	};
+
+	const clearServerCart = async () => {
+		if (!import.meta.client) {
+			return;
+		}
+		try {
+			await $fetch("/api/cart", { method: "DELETE" });
+		}
+		catch { /* best-effort */ }
+	};
+
+	const initFromServer = async () => {
+		if (!import.meta.client) {
+			return;
+		}
+		try {
+			const data = await $fetch<{ items: CartItem[] }>("/api/cart");
+			if (liveCarts.value) {
+				// Live mode: the carts app is the source of truth.
+				if (data.items.length > 0) {
+					items.value = data.items;
+				}
+				else if (items.value.length > 0) {
+					void syncToServer();
+				}
+				void refreshCartList();
+			}
+			else if (data.items.length > 0 && items.value.length === 0) {
+				items.value = data.items;
+			}
+			else if (items.value.length > 0) {
+				void syncToServer();
+			}
+		}
+		catch { /* best-effort; continue with local cart */ }
+	};
+
+	/** After a live login the BFF merged/claimed the session carts — adopt the server state. */
+	const onAuthLogin = async () => {
+		if (!import.meta.client || !liveCarts.value) {
+			return;
+		}
+		try {
+			const data = await $fetch<{ items: CartItem[] }>("/api/cart");
+			items.value = data.items;
+			requisitions.value = [];
+			await refreshCartList();
+		}
+		catch { /* best-effort */ }
+	};
+
+	/** Logout: the customer's carts stay server-side; the local view resets to the guest scope. */
+	const onAuthLogout = async () => {
+		if (!import.meta.client || !liveCarts.value) {
+			return;
+		}
+		items.value = [];
+		requisitions.value = [];
+		serverCarts.value = [];
+		activeCartId.value = "default";
+		activeCartName.value = "Mein Warenkorb";
+		await refreshCartList();
+	};
+
+	const getEffectivePrice = (id: string) => {
+		return effectivePrices.value.get(id) ?? 0;
+	};
+
+	/* ---- multiple carts: switch, create, rename, delete ----------------- */
+	const valueOf = (cartItems: CartItem[]): number =>
+		Math.round(cartItems.reduce((sum, item) => sum + resolveUnitPrice(item) * item.quantity, 0) * 100) / 100;
+
+	const persistMultiCarts = () => {
+		if (!import.meta.client) {
+			return;
+		}
+		localStorage.setItem(MULTI_CART_STORAGE, JSON.stringify({
+			activeId: activeCartId.value,
+			activeName: activeCartName.value,
+			extra: extraCarts.value,
+		}));
+	};
+
+	/** All carts (active first) as summary rows for switcher and account page. */
+	const cartSummaries = computed<CartSummaryEntry[]>(() => {
+		if (liveCarts.value && serverCarts.value.length > 0) {
+			// Server truth, but the ACTIVE row reflects the local cart live
+			// (instant feedback between debounced syncs).
+			return serverCarts.value
+				.map(row => row.active
+					? { ...row, itemCount: itemCount.value, positions: items.value.length, value: valueOf(items.value) }
+					: row)
+				.sort((a, b) => Number(b.active) - Number(a.active));
+		}
+		return localCartSummaries.value;
+	});
+
+	const localCartSummaries = computed<CartSummaryEntry[]>(() => [
+		{
+			id: activeCartId.value,
+			name: activeCartName.value,
+			itemCount: itemCount.value,
+			positions: items.value.length,
+			value: valueOf(items.value),
+			updatedAt: new Date().toISOString(),
+			active: true,
+		},
+		...extraCarts.value.map(cart => ({
+			id: cart.id,
+			name: cart.name,
+			itemCount: cart.items.reduce((sum, i) => sum + i.quantity, 0),
+			positions: cart.items.length,
+			value: valueOf(cart.items),
+			updatedAt: cart.updatedAt,
+			active: false,
+		})),
+	]);
+
+	const switchCart = (cartId: string) => {
+		if (cartId === activeCartId.value) {
+			return;
+		}
+		if (liveCarts.value) {
+			if (!SERVER_CART_ID.test(cartId)) {
+				return;
+			}
+			void (async () => {
+				try {
+					const data = await $fetch<{ items: CartItem[] }>(`/api/carts/${cartId}/activate`, { method: "POST" });
+					items.value = data.items;
+					requisitions.value = [];
+					const row = serverCarts.value.find(c => c.id === cartId);
+					activeCartId.value = cartId;
+					if (row) {
+						activeCartName.value = row.name;
+					}
+					await refreshCartList();
+				}
+				catch { /* keep the current cart on failure */ }
+			})();
+			return;
+		}
+		const target = extraCarts.value.find(cart => cart.id === cartId);
+		if (!target) {
+			return;
+		}
+		// Stash the current active cart, then activate the target.
+		extraCarts.value = [
+			{
+				id: activeCartId.value,
+				name: activeCartName.value,
+				items: items.value,
+				requisitions: requisitions.value,
+				updatedAt: new Date().toISOString(),
+			},
+			...extraCarts.value.filter(cart => cart.id !== cartId),
+		];
+		activeCartId.value = target.id;
+		activeCartName.value = target.name;
+		items.value = target.items;
+		requisitions.value = target.requisitions;
+		persistMultiCarts();
+		void syncToServer();
+	};
+
+	const createCart = (name: string, activate = true): string => {
+		if (liveCarts.value) {
+			void (async () => {
+				try {
+					const row = await $fetch<CartSummaryEntry>("/api/carts", { method: "POST", body: { name, activate } });
+					if (activate) {
+						items.value = [];
+						requisitions.value = [];
+						activeCartId.value = row.id;
+						activeCartName.value = row.name;
+					}
+					await refreshCartList();
+				}
+				catch { /* best-effort */ }
+			})();
+			return activeCartId.value;
+		}
+		const id = `cart-${Date.now().toString(36)}`;
+		extraCarts.value = [
+			...extraCarts.value,
+			{ id, name: name.trim() || "Warenkorb", items: [], requisitions: [], updatedAt: new Date().toISOString() },
+		];
+		if (activate) {
+			switchCart(id);
+		}
+		else {
+			persistMultiCarts();
+		}
+		return id;
+	};
+
+	const renameCart = (cartId: string, name: string) => {
+		const trimmed = name.trim();
+		if (!trimmed) {
+			return;
+		}
+		if (liveCarts.value) {
+			if (cartId === activeCartId.value) {
+				activeCartName.value = trimmed;
+			}
+			// Only server carts (uuid ids) exist in the carts app — the local
+			// placeholder id ("default") has nothing to rename server-side.
+			if (SERVER_CART_ID.test(cartId)) {
+				void $fetch(`/api/carts/${cartId}`, { method: "PUT", body: { name: trimmed } })
+					.then(() => refreshCartList())
+					.catch(() => { /* best-effort */ });
+			}
+			return;
+		}
+		if (cartId === activeCartId.value) {
+			activeCartName.value = trimmed;
+		}
+		else {
+			const cart = extraCarts.value.find(c => c.id === cartId);
+			if (cart) {
+				cart.name = trimmed;
+			}
+		}
+		persistMultiCarts();
+	};
+
+	const deleteCart = (cartId: string) => {
+		if (liveCarts.value) {
+			if (!SERVER_CART_ID.test(cartId)) {
+				return;
+			}
+			void (async () => {
+				try {
+					await $fetch(`/api/carts/${cartId}`, { method: "DELETE" });
+					if (cartId === activeCartId.value) {
+						items.value = [];
+						requisitions.value = [];
+						await refreshCartList();
+						const next = serverCarts.value.find(c => c.id !== cartId);
+						if (next) {
+							switchCart(next.id);
+						}
+						else {
+							activeCartId.value = "default";
+							activeCartName.value = "Mein Warenkorb";
+						}
+					}
+					else {
+						await refreshCartList();
+					}
+				}
+				catch { /* best-effort */ }
+			})();
+			return;
+		}
+		if (cartId === activeCartId.value) {
+			// Deleting the active cart activates the next one (or a fresh default).
+			const next = extraCarts.value[0];
+			if (next) {
+				extraCarts.value = extraCarts.value.filter(cart => cart.id !== next.id);
+				activeCartId.value = next.id;
+				activeCartName.value = next.name;
+				items.value = next.items;
+				requisitions.value = next.requisitions;
+			}
+			else {
+				activeCartId.value = "default";
+				activeCartName.value = "Mein Warenkorb";
+				items.value = [];
+				requisitions.value = [];
+			}
+		}
+		else {
+			extraCarts.value = extraCarts.value.filter(cart => cart.id !== cartId);
+		}
+		persistMultiCarts();
+		void syncToServer();
+	};
+
+	/** Moves the line of a pending add into another cart (target-cart dialog). */
+	const moveLineToCart = (lineKey: string, cartId: string) => {
+		if (cartId === activeCartId.value) {
+			return;
+		}
+		const target = extraCarts.value.find(cart => cart.id === cartId);
+		const line = findByKey(lineKey);
+		if (!target || !line) {
+			return;
+		}
+		items.value = items.value.filter(i => keyOf(i) !== lineKey);
+		const existing = target.items.find(i => i.id === line.id && !i.requisitionId);
+		if (existing) {
+			existing.quantity += line.quantity;
+		}
+		else {
+			target.items.push(line);
+		}
+		target.updatedAt = new Date().toISOString();
+		persistMultiCarts();
+	};
+
+	const setAlwaysActiveCart = (value: boolean) => {
+		alwaysActiveCart.value = value;
+		if (import.meta.client) {
+			localStorage.setItem(ADD_PREF_STORAGE, value ? "1" : "0");
+		}
+	};
+
+	const openCart = () => {
+		isOpen.value = true;
+	};
+	const closeCart = () => {
+		isOpen.value = false;
+	};
+	const toggleCart = () => {
+		isOpen.value = !isOpen.value;
+	};
+
+	if (import.meta.client) {
+		const COOKIE_NAME = "cover-cart-has-items";
+		const cookieMaxAge = Math.floor(cartInactivityTtl / 1000);
+
+		const setCartCookie = () => {
+			document.cookie = `${COOKIE_NAME}=1; path=/; SameSite=Lax; max-age=${cookieMaxAge}`;
+		};
+		const clearCartCookie = () => {
+			document.cookie = `${COOKIE_NAME}=; path=/; SameSite=Lax; max-age=0`;
+		};
+
+		let inactivityTimer: ReturnType<typeof setTimeout> | null = null;
+
+		const clearTimer = () => {
+			if (inactivityTimer) {
+				clearTimeout(inactivityTimer);
+				inactivityTimer = null;
+			}
+		};
+
+		const scheduleExpiry = (delay = cartInactivityTtl) => {
+			clearTimer();
+			inactivityTimer = setTimeout(() => {
+				items.value = [];
+			}, delay);
+		};
+
+		let lastPersistAt = 0;
+		const PERSIST_THROTTLE = 30_000;
+
+		const onUserActivity = () => {
+			if (items.value.length === 0) {
+				return;
+			}
+			setCartCookie();
+			scheduleExpiry();
+			const now = Date.now();
+			if (now - lastPersistAt > PERSIST_THROTTLE) {
+				lastPersistAt = now;
+				localStorage.setItem("cover-cart", JSON.stringify({
+					items: items.value,
+					requisitions: requisitions.value,
+					lastActivityAt: new Date(now).toISOString(),
+				}));
+			}
+		};
+
+		document.addEventListener("click", onUserActivity, { passive: true });
+		document.addEventListener("scroll", onUserActivity, { passive: true, capture: true });
+
+		// Restore the multi-cart state (stashed carts + active cart meta and
+		// the add-target preference) — independent of the active cart's TTL.
+		const savedMulti = localStorage.getItem(MULTI_CART_STORAGE);
+		if (savedMulti) {
+			try {
+				const parsed = JSON.parse(savedMulti) as {
+					activeId: string;
+					activeName: string;
+					extra: NamedCart[];
+				};
+				activeCartId.value = parsed.activeId || "default";
+				activeCartName.value = parsed.activeName || "Mein Warenkorb";
+				extraCarts.value = parsed.extra ?? [];
+			}
+			catch {
+				// ignore malformed stored data
+			}
+		}
+		alwaysActiveCart.value = localStorage.getItem(ADD_PREF_STORAGE) === "1";
+
+		const saved = localStorage.getItem("cover-cart");
+		if (saved) {
+			try {
+				const { items: savedItems, requisitions: savedRequisitions, lastActivityAt } = JSON.parse(saved) as PersistedCart;
+				const elapsed = Date.now() - new Date(lastActivityAt).getTime();
+				if (elapsed < cartInactivityTtl) {
+					items.value = savedItems;
+					requisitions.value = savedRequisitions ?? [];
+					setCartCookie();
+					scheduleExpiry(cartInactivityTtl - elapsed);
+				}
+				else {
+					localStorage.removeItem("cover-cart");
+				}
+			}
+			catch {
+				// ignore malformed stored data
+			}
+		}
+
+		let syncTimer: ReturnType<typeof setTimeout> | null = null;
+
+		const debouncedSyncToServer = () => {
+			if (syncTimer) {
+				clearTimeout(syncTimer);
+			}
+			syncTimer = setTimeout(() => {
+				syncTimer = null;
+				void syncToServer();
+			}, 500);
+		};
+
+		watch(items, (val) => {
+			if (val.length > 0) {
+				setCartCookie();
+				localStorage.setItem("cover-cart", JSON.stringify({
+					items: val,
+					requisitions: requisitions.value,
+					lastActivityAt: new Date().toISOString(),
+				}));
+				scheduleExpiry();
+			}
+			else {
+				clearCartCookie();
+				clearTimer();
+				localStorage.removeItem("cover-cart");
+			}
+			debouncedSyncToServer();
+		}, { deep: true });
+
+		onScopeDispose(() => {
+			clearTimer();
+			if (syncTimer) {
+				clearTimeout(syncTimer);
+			}
+			document.removeEventListener("click", onUserActivity);
+			document.removeEventListener("scroll", onUserActivity, { capture: true });
+		});
+	}
+
+	return {
+		items, requisitions, isOpen, itemCount, effectivePrices, getEffectivePrice,
+		subtotal, subtotalDisplay, visibleTaxRows, tax, total, TAX_RATE, isEmpty,
+		addItem, removeItem, updateQuantity, clearCart,
+		keyOf, removeByKeys, updateQuantityByKey, setCostCenter, setPositionDetails,
+		moveWithinScope, addRequisition, removeRequisition,
+		openCart, closeCart, toggleCart,
+		syncToServer, clearServerCart, initFromServer,
+		// live carts (carts app)
+		liveCarts, serverCarts, refreshCartList, onAuthLogin, onAuthLogout,
+		// multiple carts (feature-flagged)
+		activeCartId, activeCartName, extraCarts, cartSummaries,
+		switchCart, createCart, renameCart, deleteCart, moveLineToCart,
+		alwaysActiveCart, setAlwaysActiveCart, interceptAdds, pendingAdd,
+	};
+});