@zenky/storefront-vue 0.9.46 → 0.10.0

package/dist/chunk-OQLU7FSR.js

@@ -0,0 +1,1841 @@
+import { useCartCredentials, usePromotionsChecker } from './chunk-4MJKN7PL.js';
+import { createRuntimeState } from './chunk-5QCUH3FF.js';
+import { useCatalogStore } from './chunk-Z3IW4ODZ.js';
+import { usePromotionsStore } from './chunk-BWUKMWHL.js';
+import { useStoreProfileStore, useAuthStore } from './chunk-PWHIDGKW.js';
+import { getRemoteCatalog } from './chunk-EYRCAUUP.js';
+import { useCartStore, useOrderSettingsStore } from './chunk-VL3T36VM.js';
+import { useRuntime } from './chunk-V3VVDQIR.js';
+import { minorToMajor, majorToMinor } from './chunk-RO25KNM5.js';
+import { PaymentMethod, OrderAuthenticationMethod, DeliveryMethod, OrderCartCheckerResultAction, RecaptchaAction } from '@zenky/storefront-api';
+import { computed, ref, watch, watchEffect, getCurrentScope, onScopeDispose, toValue } from 'vue';
+import { storeToRefs } from 'pinia';
+
+// src/cart/constants.ts
+var ORDER_EVENTS = {
+  PriceRecalculated: "orders.price.recalculated",
+  Reload: "orders.reload",
+  Submitted: "orders.submitted",
+  Repeated: "orders.repeated",
+  PromotionsNotFound: "orders.promotions.not_found",
+  RewardsDisplaySelection: "orders.rewards.display_selection",
+  RewardsReload: "orders.rewards.reload"
+};
+
+// src/cart/normalizeAddress.ts
+function normalizeAddress(value) {
+  if (!value) return "";
+  return value.toLowerCase().replace(/[,\s]+/g, " ").trim();
+}
+
+// src/cart/cartLineKey.ts
+function buildCartLineKey(params) {
+  const modifiers = (params.modifiers ?? []).map((m) => `${m.modifier_id ?? ""}:${m.quantity}`).sort().join("|");
+  return [
+    params.productVariantId,
+    modifiers,
+    params.promotionId ?? "",
+    params.promotionRewardId ?? ""
+  ].join("::");
+}
+function variantLineKey(variant) {
+  const modifiers = (variant.modifiers ?? []).map((m) => ({
+    modifier_id: m.modifier?.id ?? m.id,
+    modifiers_group_id: m.modifiers_group_id ?? void 0,
+    quantity: m.quantity
+  }));
+  return buildCartLineKey({
+    productVariantId: variant.product_variant_id,
+    modifiers,
+    promotionId: variant.promotion?.id,
+    promotionRewardId: variant.promotion?.reward_id
+  });
+}
+function buildMainPaymentRequest(params) {
+  if (!params.method || params.method === PaymentMethod.Bonuses) return null;
+  return {
+    method: params.method,
+    bill: params.billMinor != null && params.billMinor > 0 ? minorToMajor(params.billMinor, params.currency) : void 0,
+    save_card: params.saveCard,
+    card_token_id: params.cardTokenId ?? void 0
+  };
+}
+
+// src/cart/cashChangePresets.ts
+var CASH_DENOMINATIONS_MAJOR = {
+  RU: [10, 50, 100, 200, 500, 1e3, 2e3, 5e3, 1e4],
+  KZ: [200, 500, 1e3, 2e3, 5e3, 1e4, 2e4],
+  BY: [5, 10, 20, 50, 100, 200, 500],
+  UA: [1, 2, 5, 10, 20, 50, 100, 200, 500, 1e3]
+};
+var DEFAULT_ROUND_STEPS_MAJOR = [10, 50, 100, 200, 500, 1e3];
+function getDefaultRoundStepsMinor(currency = "RUB") {
+  return DEFAULT_ROUND_STEPS_MAJOR.map((value) => majorToMinor(value, currency));
+}
+function getCashDenominationsMinor(country, currency = "RUB") {
+  const code = country ?? "RU";
+  const major = CASH_DENOMINATIONS_MAJOR[code] ?? CASH_DENOMINATIONS_MAJOR.RU ?? [];
+  return major.map((d) => majorToMinor(d, currency));
+}
+function buildCashChangePresets({
+  totalMinor,
+  denominationsMinor,
+  roundStepsMinor = getDefaultRoundStepsMinor()
+}) {
+  const total = Math.max(totalMinor, 0);
+  if (total === 0) return [...denominationsMinor];
+  const candidates = /* @__PURE__ */ new Set();
+  for (const step of roundStepsMinor) {
+    candidates.add(Math.ceil((total + 1) / step) * step);
+  }
+  for (const d of denominationsMinor) {
+    if (d > total) candidates.add(d);
+  }
+  return [...candidates].sort((a, b) => a - b);
+}
+
+// src/cart/logCartError.ts
+function logCartError({ scope, context }, e) {
+  const err = e?.err;
+  console.error(`[${scope}] failed`, {
+    ...context ?? {},
+    httpCode: err?.http_code,
+    errorCode: err?.error_code,
+    message: err?.message,
+    meta: err?.meta,
+    // raw — полный объект ошибки на случай нестандартных полей
+    raw: e
+  });
+}
+function getCartErrorCode(e) {
+  return e?.err?.error_code;
+}
+function getCartErrorHttpCode(e) {
+  return e?.err?.http_code;
+}
+function getValidationErrors(e) {
+  const err = e?.err;
+  if (!err || err.error_code !== "validation") return {};
+  const meta = err.meta;
+  return meta?.errors ?? {};
+}
+function getCartErrorMessage(e, fallback) {
+  const err = e?.err;
+  if (!err) return fallback;
+  if (err.error_code === "validation") {
+    const errors = err.meta?.errors;
+    if (errors) {
+      const messages = Object.values(errors).flat().filter(Boolean);
+      if (messages.length > 0) return messages.join(" ");
+    }
+  }
+  return err.message ?? fallback;
+}
+
+// src/cart/useCartMutation.ts
+var getMutationState = createRuntimeState(() => ({
+  versions: /* @__PURE__ */ new Map()
+}));
+function useCartMutation() {
+  const runtime = useRuntime();
+  const { versions } = getMutationState(runtime);
+  async function run(options, fn) {
+    const { kind, debounce = 0 } = options;
+    const myVersion = (versions.get(kind) ?? 0) + 1;
+    versions.set(kind, myVersion);
+    const isStale = () => versions.get(kind) !== myVersion;
+    if (debounce > 0) {
+      await new Promise((resolve) => setTimeout(resolve, debounce));
+      if (isStale()) return void 0;
+    }
+    try {
+      return await fn(isStale);
+    } catch (e) {
+      if (isStale()) return void 0;
+      throw e;
+    }
+  }
+  function getVersion(kind) {
+    return versions.get(kind) ?? 0;
+  }
+  function bumpKindsWithPrefix(prefix) {
+    for (const kind of versions.keys()) {
+      if (kind.startsWith(prefix)) {
+        versions.set(kind, (versions.get(kind) ?? 0) + 1);
+      }
+    }
+  }
+  return { run, getVersion, bumpKindsWithPrefix };
+}
+function useCartQuantities() {
+  const cartStore = useCartStore();
+  function getProductQuantity(productId) {
+    return computed(() => {
+      const serverQty = cartStore.productQuantities[productId] ?? 0;
+      const adjustment = cartStore.optimisticAdjustments[productId] ?? 0;
+      return Math.max(0, serverQty + adjustment);
+    });
+  }
+  function getVariantQuantity(productVariantId, modifiers) {
+    return computed(() => {
+      const variantId = toValue(productVariantId);
+      if (!variantId) return 0;
+      const requestedMods = toValue(modifiers);
+      const match = cartStore.variants.find((cartItem) => {
+        if (cartItem.product_variant_id !== variantId) return false;
+        const cartMods = cartItem.modifiers ?? [];
+        if (cartMods.length !== requestedMods.length) return false;
+        if (requestedMods.length === 0) return true;
+        return requestedMods.every(
+          (mod) => cartMods.some((cm) => cm.id === mod.modifier_id && cm.quantity === mod.quantity)
+        );
+      });
+      return match?.quantity ?? 0;
+    });
+  }
+  return {
+    getProductQuantity,
+    getVariantQuantity
+  };
+}
+function useCheckoutFlow() {
+  const profileStore = useStoreProfileStore();
+  const mode = computed(
+    () => profileStore.store?.settings?.orders?.authentication_method ?? OrderAuthenticationMethod.Disabled
+  );
+  const needsAuth = computed(() => mode.value === OrderAuthenticationMethod.Preauth);
+  const needsCustomerForm = computed(
+    () => mode.value === OrderAuthenticationMethod.Disabled || mode.value === OrderAuthenticationMethod.Confirmation
+  );
+  return { mode, needsAuth, needsCustomerForm };
+}
+function useOrderTotal() {
+  const loading = ref(false);
+  const sdk = useRuntime().sdk;
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { run } = useCartMutation();
+  const total = computed(() => cartStore.checkoutTotal);
+  async function fetchTotal() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    await run({ kind: "total", debounce: 100 }, async (isStale) => {
+      try {
+        const orderCredentials = credentials.getCredentials();
+        loading.value = true;
+        const fresh = await sdk.orders.getOrderTotal(storeId, orderCredentials);
+        if (isStale()) return;
+        cartStore.setCheckoutTotal(fresh);
+      } catch (e) {
+        if (isStale()) return;
+        logCartError(
+          { scope: "order-total", context: { orderId: cartStore.credentials?.id } },
+          e
+        );
+      } finally {
+        loading.value = false;
+      }
+    });
+  }
+  return { total, loading, fetchTotal };
+}
+function useOrderSettings() {
+  const sdk = useRuntime().sdk;
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { run } = useCartMutation();
+  const loading = ref(false);
+  const settings = computed(() => cartStore.orderSettings);
+  const paymentMethods = computed(() => cartStore.paymentMethods);
+  const deliveryMethods = computed(() => cartStore.deliveryMethods);
+  async function fetchSettings() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    await run({ kind: "settings" }, async (isStale) => {
+      loading.value = true;
+      try {
+        const orderCredentials = credentials.getCredentials();
+        const fresh = await sdk.orders.getOrderSettings(storeId, orderCredentials);
+        if (isStale()) return;
+        cartStore.setOrderSettings(fresh);
+      } catch (e) {
+        if (isStale()) return;
+        logCartError(
+          { scope: "order-settings", context: { orderId: cartStore.credentials?.id } },
+          e
+        );
+      } finally {
+        loading.value = false;
+      }
+    });
+  }
+  return { settings, paymentMethods, deliveryMethods, loading, fetchSettings };
+}
+
+// src/cart/useOnlinePaymentRetry.ts
+function useOnlinePaymentRetry() {
+  const sdk = useRuntime().sdk;
+  const profileStore = useStoreProfileStore();
+  async function retry(creds, options = {}) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return null;
+    if (!creds.id) return null;
+    const credentials = { id: creds.id, token: creds.token ?? "" };
+    const currentUrl = options.currentUrl ?? (typeof window === "undefined" ? null : window.location.href);
+    if (!currentUrl) return null;
+    try {
+      const redirect = await sdk.orders.retryOnlinePayment(storeId, credentials, {
+        current_url: currentUrl
+      });
+      if (redirect?.redirect_url) {
+        return redirect.redirect_url;
+      }
+    } catch (e) {
+      if (!options.transactionId) {
+        logCartError({ scope: "payment-retry", context: { orderId: creds.id } }, e);
+        return null;
+      }
+    }
+    if (!options.transactionId) return null;
+    try {
+      const redirect = await sdk.orders.getOnlinePaymentRedirect(
+        storeId,
+        credentials,
+        options.transactionId,
+        { current_url: currentUrl }
+      );
+      return redirect?.redirect_url ?? null;
+    } catch (e) {
+      logCartError(
+        {
+          scope: "payment-retry-fallback",
+          context: { orderId: creds.id, transactionId: options.transactionId }
+        },
+        e
+      );
+      return null;
+    }
+  }
+  return { retry };
+}
+function useCartAddressSync() {
+  const authStore = useAuthStore();
+  const orderSettings = useOrderSettingsStore();
+  const profileStore = useStoreProfileStore();
+  const sdk = useRuntime().sdk;
+  async function syncOnLogin() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    const requestedToken = authStore.token;
+    if (!requestedToken) return;
+    let addresses;
+    try {
+      const response = await sdk.customer.getAddresses(storeId, void 0, requestedToken);
+      addresses = response.items ?? [];
+    } catch (e) {
+      console.error("[address-sync] failed to fetch saved addresses", e);
+      return;
+    }
+    if (!authStore.isAuthenticated || authStore.token !== requestedToken) return;
+    if (addresses.length === 0) return;
+    if (!orderSettings.selectedAddress) {
+      const first = addresses[0];
+      if (!first) return;
+      orderSettings.setSelectedAddress(first.address, first.id, first.name);
+      return;
+    }
+    if (orderSettings.selectedAddressId && addresses.some((a) => a.id === orderSettings.selectedAddressId)) {
+      return;
+    }
+    const normalizedSelected = normalizeAddress(orderSettings.selectedAddress);
+    const match = addresses.find((a) => normalizeAddress(a.address) === normalizedSelected);
+    if (match) {
+      orderSettings.setSelectedAddress(match.address, match.id, match.name);
+      return;
+    }
+    orderSettings.setSelectedAddress(null, null, null);
+  }
+  watch(
+    () => authStore.isAuthenticated,
+    async (isAuth, wasAuth) => {
+      if (isAuth && !wasAuth) await syncOnLogin();
+    }
+  );
+}
+
+// src/cart/useCartInitialization.ts
+var ORDER_INCLUDES = [
+  "city.schedule",
+  "stock.schedule",
+  "delivery_address",
+  "delivery_interval",
+  "customer",
+  "payments",
+  "progress",
+  "promocode",
+  "variants.variant.options",
+  "variants.product.images",
+  "variants.product.categories",
+  "variants.modifiers.modifier",
+  "variants.modifiers.modifiers_group"
+].join(",");
+var ORDER_WITH = { with: ORDER_INCLUDES };
+var getInitializationState = createRuntimeState(() => ({ promise: null }));
+function useCartInitialization(credentials, sdk) {
+  const cartStore = useCartStore();
+  const runtime = useRuntime();
+  const state = getInitializationState(runtime);
+  const { fetchTotal } = useOrderTotal();
+  async function createNewOrder() {
+    const storeId = credentials.getStoreId();
+    const cityId = credentials.getCityId();
+    const apiToken = credentials.getApiToken();
+    const newOrder = await sdk.orders.createOrder(storeId, { city_id: cityId }, apiToken);
+    cartStore.setOrder(newOrder);
+    credentials.persistCredentials(newOrder);
+    runtime.events?.get()?.orderCreated({ order: newOrder });
+  }
+  async function loadOrderSettings() {
+    try {
+      const storeId = credentials.getStoreId();
+      const orderCredentials = credentials.getCredentials();
+      const settings = await sdk.orders.getOrderSettings(storeId, orderCredentials);
+      cartStore.setOrderSettings(settings);
+    } catch (e) {
+      console.error("[cart] Failed to load order settings", e);
+    }
+  }
+  async function _doInitialize() {
+    cartStore.setInitializing(true);
+    try {
+      if (credentials.orderIdCookie.value && credentials.orderTokenCookie.value) {
+        const orderCredentials = credentials.buildCredentials(
+          credentials.orderIdCookie.value,
+          credentials.orderTokenCookie.value
+        );
+        try {
+          const storeId = credentials.getStoreId();
+          const existingOrder = await sdk.orders.getOrder(
+            storeId,
+            orderCredentials,
+            ORDER_WITH
+          );
+          if (credentials.isOrderActive(existingOrder)) {
+            cartStore.setOrder(existingOrder);
+            runtime.events?.get()?.orderLoaded({ order: existingOrder });
+            return;
+          }
+          credentials.clearPersistedCredentials();
+          cartStore.clearCart();
+        } catch {
+          credentials.clearPersistedCredentials();
+          cartStore.clearCart();
+        }
+      }
+      await createNewOrder();
+    } catch (e) {
+      runtime.events?.get()?.orderInitializationFailed();
+      throw e;
+    } finally {
+      if (cartStore.hasCredentials) {
+        await loadOrderSettings();
+        if (cartStore.order?.variants?.length) {
+          await fetchTotal();
+        }
+      }
+      cartStore.setInitializing(false);
+    }
+  }
+  function initializeOrder() {
+    if (cartStore.hasOrder) return Promise.resolve();
+    if (state.promise !== null) return state.promise;
+    state.promise = _doInitialize().finally(() => {
+      state.promise = null;
+    });
+    return state.promise;
+  }
+  return {
+    initializeOrder
+  };
+}
+function useOrderBonuses(deps = {}) {
+  const runtime = useRuntime();
+  const activity = deps.activity ?? runtime.activity;
+  const sdk = runtime.sdk;
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { total, fetchTotal } = useOrderTotal();
+  const { run: runMutation } = useCartMutation();
+  const maxAvailable = computed(() => total.value?.max_bonuses_payment ?? 0);
+  function bonusesAmountToApi(amount) {
+    const currency = profileStore.store?.settings?.currency ?? "RUB";
+    return minorToMajor(amount, currency);
+  }
+  async function apply(additionalPayments = [], pin, amount) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    const requested = amount ?? maxAvailable.value;
+    const finalAmount = Math.min(requested, maxAvailable.value);
+    if (!Number.isFinite(finalAmount) || finalAmount <= 0) return;
+    const bonusesPayment = {
+      method: PaymentMethod.Bonuses,
+      amount: bonusesAmountToApi(finalAmount)
+    };
+    if (pin) bonusesPayment.pin = pin;
+    try {
+      await runMutation({ kind: "bonuses" }, async (isStale) => {
+        activity.begin("bonuses");
+        try {
+          const orderCredentials = credentials.getCredentials();
+          const updatedOrder = await sdk.orders.setOrderPayments(storeId, orderCredentials, {
+            payments: [...additionalPayments, bonusesPayment]
+          });
+          if (isStale()) return;
+          if (Array.isArray(updatedOrder)) {
+            cartStore.setOrderPaymentsState(updatedOrder);
+          } else {
+            cartStore.setOrder(updatedOrder);
+          }
+          await fetchTotal();
+        } finally {
+          activity.end("bonuses");
+        }
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "bonuses-apply",
+          context: { amount, orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+      throw e;
+    }
+  }
+  async function remove(mainPayment) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    try {
+      await runMutation({ kind: "bonuses" }, async (isStale) => {
+        activity.begin("bonuses");
+        try {
+          const orderCredentials = credentials.getCredentials();
+          const updatedOrder = await sdk.orders.setOrderPayments(storeId, orderCredentials, {
+            payments: mainPayment ? [mainPayment] : []
+          });
+          if (isStale()) return;
+          if (Array.isArray(updatedOrder)) {
+            cartStore.setOrderPaymentsState(updatedOrder);
+          } else {
+            cartStore.setOrder(updatedOrder);
+          }
+          await fetchTotal();
+        } finally {
+          activity.end("bonuses");
+        }
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "bonuses-remove",
+          context: { orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+      throw e;
+    }
+  }
+  return {
+    maxAvailable,
+    apply,
+    remove
+  };
+}
+var PAYMENT_DEBOUNCE_MS = 300;
+function usePaymentSelection() {
+  const { sdk, notifier, activity } = useRuntime();
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { fetchTotal } = useOrderTotal();
+  const { run: runMutation } = useCartMutation();
+  async function sendPayments(payments, debounce = PAYMENT_DEBOUNCE_MS) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    await runMutation({ kind: "payment", debounce }, async (isStale) => {
+      activity.begin("payment");
+      try {
+        const orderCredentials = credentials.getCredentials();
+        const result = await sdk.orders.setOrderPayments(storeId, orderCredentials, {
+          payments
+        });
+        if (isStale()) return;
+        if (Array.isArray(result)) {
+          cartStore.setOrderPaymentsState(result);
+        } else {
+          cartStore.patchOrder(result);
+        }
+        await fetchTotal();
+      } catch (e) {
+        if (isStale()) return;
+        logCartError(
+          {
+            scope: "payment",
+            context: {
+              methods: payments.map((p) => p.method),
+              count: payments.length,
+              orderId: cartStore.credentials?.id
+            }
+          },
+          e
+        );
+        notifier.error(getCartErrorMessage(e, "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u0441\u043F\u043E\u0441\u043E\u0431 \u043E\u043F\u043B\u0430\u0442\u044B"));
+      } finally {
+        activity.end("payment");
+      }
+    });
+  }
+  function buildPaymentRequest(selection) {
+    const payment = { method: selection.method };
+    if (selection.bill != null && selection.bill > 0) {
+      const currency = profileStore.store?.settings?.currency ?? "RUB";
+      payment.bill = minorToMajor(selection.bill, currency);
+    }
+    if (selection.save_card !== void 0) payment.save_card = selection.save_card;
+    if (selection.card_token_id) payment.card_token_id = selection.card_token_id;
+    return payment;
+  }
+  function getCurrentBonusesPayment() {
+    if (!cartStore.hasBonusesApplied) return null;
+    const { total } = useOrderTotal();
+    const bonusPayment = total.value?.payments?.find(
+      (p) => p.method === PaymentMethod.Bonuses
+    );
+    const amountMinor = bonusPayment ? Number(bonusPayment.amount) : 0;
+    if (!Number.isFinite(amountMinor) || amountMinor <= 0) return null;
+    const currency = profileStore.store?.settings?.currency ?? "RUB";
+    return {
+      method: PaymentMethod.Bonuses,
+      amount: minorToMajor(amountMinor, currency)
+    };
+  }
+  function buildPaymentsWithBonuses(selection) {
+    const main = buildPaymentRequest(selection);
+    const bonuses = getCurrentBonusesPayment();
+    return bonuses ? [main, bonuses] : [main];
+  }
+  async function setPayment(selection) {
+    await sendPayments(buildPaymentsWithBonuses(selection));
+  }
+  async function syncPaymentNow(selection) {
+    await sendPayments(buildPaymentsWithBonuses(selection), 0);
+  }
+  async function clearPayments() {
+    await sendPayments([]);
+  }
+  return { setPayment, syncPaymentNow, clearPayments };
+}
+function useBonusesReconciliation(deps) {
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { maxAvailable, apply, remove } = useOrderBonuses({ activity: deps.activity });
+  function isPinEnabled() {
+    return profileStore.store?.settings?.loyalty?.bonuses?.pin_enabled ?? false;
+  }
+  function mainPayment() {
+    return buildMainPaymentRequest({
+      method: cartStore.selectedPaymentMethod,
+      billMinor: cartStore.selectedPaymentBill,
+      cardTokenId: cartStore.selectedCardTokenId,
+      saveCard: cartStore.selectedSaveCard,
+      currency: profileStore.store?.settings?.currency ?? "RUB"
+    });
+  }
+  function appliedBonusesMinor() {
+    const payments = cartStore.checkoutTotal?.payments ?? [];
+    const bonus = payments.find((p) => p.method === PaymentMethod.Bonuses);
+    return bonus?.amount ?? 0;
+  }
+  async function reconcileAfterOrderChange() {
+    const intent = cartStore.bonusesIntent;
+    if (!intent.enabled) return;
+    const payment = mainPayment();
+    if (maxAvailable.value <= 0) {
+      try {
+        if (cartStore.hasBonusesApplied) await remove(payment);
+      } catch (e) {
+        logCartError(
+          {
+            scope: "bonuses-reconcile-unavailable",
+            context: { orderId: cartStore.credentials?.id }
+          },
+          e
+        );
+      }
+      cartStore.setBonusesIntentEnabled(false);
+      return;
+    }
+    if (isPinEnabled()) {
+      try {
+        if (cartStore.hasBonusesApplied) await remove(payment);
+      } catch (e) {
+        logCartError(
+          {
+            scope: "bonuses-reconcile-pin",
+            context: { orderId: cartStore.credentials?.id }
+          },
+          e
+        );
+      }
+      cartStore.setBonusesRequiresConfirmation(true);
+      deps.notifier.message("\u0421\u043E\u0441\u0442\u0430\u0432 \u0437\u0430\u043A\u0430\u0437\u0430 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F", {
+        description: "\u041F\u043E\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u0442\u0435 \u0441\u043F\u0438\u0441\u0430\u043D\u0438\u0435 \u0431\u043E\u043D\u0443\u0441\u043E\u0432 \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u043E"
+      });
+      return;
+    }
+    const desired = intent.desiredAmountMinor;
+    const amount = desired === null ? maxAvailable.value : Math.min(desired, maxAvailable.value);
+    if (appliedBonusesMinor() === amount) return;
+    const additionalPayments = payment ? [payment] : [];
+    try {
+      await apply(additionalPayments, void 0, amount);
+    } catch (e) {
+      logCartError(
+        { scope: "bonuses-reconcile", context: { orderId: cartStore.credentials?.id } },
+        e
+      );
+    }
+  }
+  return { reconcileAfterOrderChange };
+}
+
+// src/cart/useCartRecalculation.ts
+function useCartRecalculation(deps) {
+  const { fetchTotal } = useOrderTotal();
+  const { reconcileAfterOrderChange } = useBonusesReconciliation({
+    notifier: deps.notifier,
+    activity: deps.activity
+  });
+  const { dispatchCheck } = usePromotionsChecker();
+  async function recalculateAfterOrderChange() {
+    await fetchTotal();
+    await reconcileAfterOrderChange();
+    dispatchCheck();
+  }
+  return { recalculateAfterOrderChange };
+}
+function useCustomerAttach(cache) {
+  const { sdk, notifier, activity } = useRuntime();
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { run: runMutation } = useCartMutation();
+  const cachedCustomer = cache.forOrder(() => cartStore.order?.id ?? null);
+  const isAttached = computed(
+    () => cartStore.order?.customer != null || cachedCustomer.value != null
+  );
+  async function attach(request) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    const orderId = cartStore.credentials?.id;
+    if (!orderId) return;
+    try {
+      await runMutation({ kind: "customer" }, async (isStale) => {
+        activity.begin("custom");
+        try {
+          const orderCredentials = credentials.getCredentials();
+          await sdk.orders.setOrderCustomer(storeId, orderCredentials, request);
+          if (isStale()) return;
+          cache.set(orderId, request);
+          const fresh = await sdk.orders.getOrder(storeId, orderCredentials, ORDER_WITH);
+          if (isStale()) return;
+          cartStore.setOrder(fresh);
+        } finally {
+          activity.end("custom");
+        }
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "customer-attach",
+          context: {
+            firstName: request.first_name,
+            lastName: request.last_name,
+            phoneCountry: request.phone?.country,
+            orderId: cartStore.credentials?.id
+          }
+        },
+        e
+      );
+      notifier.error(getCartErrorMessage(e, "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043A\u043E\u043D\u0442\u0430\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435"));
+      throw e;
+    }
+  }
+  return { isAttached, attach };
+}
+function normalizePhone(phone) {
+  if (!phone) return null;
+  const digits = phone.replace(/\D/g, "");
+  return digits || null;
+}
+function useCartCustomerAttachment(cache) {
+  const { sdk, notifier } = useRuntime();
+  const authStore = useAuthStore();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const orderSettings = useOrderSettingsStore();
+  const cartCredentials = useCartCredentials();
+  async function attachCurrentUser(notifyOnPhoneChange) {
+    if (!authStore.isAuthenticated || !cartStore.hasOrder) return;
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    const requestedToken = authStore.token;
+    const requestedOrderId = cartStore.order?.id;
+    const previousPhone = notifyOnPhoneChange ? normalizePhone(
+      cartStore.order?.customer?.phone?.number ?? cache.forOrder(() => cartStore.order?.id ?? null).value?.phone?.number ?? null
+    ) : null;
+    try {
+      const credentials = cartCredentials.getCredentials();
+      await sdk.orders.setOrderCustomer(storeId, credentials, {
+        phone: { number: authStore.phone ?? "", country: authStore.countryCode }
+      });
+      console.log("[cart] customer attached to order");
+      const fresh = await sdk.orders.getOrder(storeId, credentials, ORDER_WITH);
+      if (!authStore.isAuthenticated || authStore.token !== requestedToken) return;
+      if (cartStore.order?.id !== requestedOrderId) return;
+      cartStore.setOrder(fresh);
+      cache.clear();
+      if (notifyOnPhoneChange) {
+        const newPhone = normalizePhone(fresh.customer?.phone?.number ?? null);
+        if (previousPhone && newPhone && previousPhone !== newPhone) {
+          const firstName = fresh.customer?.first_name;
+          notifier.success(
+            firstName ? `\u041A\u043E\u043D\u0442\u0430\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u044B \u2014 ${firstName}` : "\u041A\u043E\u043D\u0442\u0430\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u044B"
+          );
+        }
+      }
+    } catch (e) {
+      console.error("[cart] failed to attach customer to order", e);
+      if (notifyOnPhoneChange) {
+        notifier.error("\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u043A\u043E\u043D\u0442\u0430\u043A\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435 \u043F\u043E\u0441\u043B\u0435 \u0432\u0445\u043E\u0434\u0430");
+      }
+    }
+  }
+  async function refreshOrderAfterLogout() {
+    orderSettings.setSelectedAddress(null, null, null);
+    if (!cartStore.hasOrder) return;
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    const requestedOrderId = cartStore.order?.id;
+    try {
+      const credentials = cartCredentials.getCredentials();
+      const fresh = await sdk.orders.getOrder(storeId, credentials, ORDER_WITH);
+      if (authStore.isAuthenticated) return;
+      if (cartStore.order?.id !== requestedOrderId) return;
+      cartStore.setOrder(fresh);
+      cache.clear();
+    } catch (e) {
+      console.error("[cart] failed to refresh order after logout", e);
+    }
+  }
+  watch(
+    () => authStore.isAuthenticated,
+    async (isAuthenticated) => {
+      if (isAuthenticated) {
+        await attachCurrentUser(true);
+      } else {
+        await refreshOrderAfterLogout();
+      }
+    }
+  );
+  watch(
+    () => cartStore.order?.id,
+    async (newId, oldId) => {
+      if (!newId || newId === oldId) return;
+      if (!authStore.isAuthenticated) return;
+      if (cartStore.order?.customer) return;
+      await attachCurrentUser(false);
+    }
+  );
+}
+var KEY_STOCK_ID = "zenky_stock_id";
+var YEAR_SECONDS = 60 * 60 * 24 * 365;
+function useCartStockWatcher() {
+  const { sdk, notifier, storage, catalogReloader } = useRuntime();
+  const profileStore = useStoreProfileStore();
+  const catalogStore = useCatalogStore();
+  const cartStore = useCartStore();
+  const credentials = useCartCredentials();
+  const { fetchTotal } = useOrderTotal();
+  async function handleStockChange(updatedOrder) {
+    const newStockId = updatedOrder.stock?.id ?? null;
+    const currentStockId = profileStore.stock?.id ?? null;
+    if (newStockId === currentStockId) return;
+    try {
+      profileStore.setStock(updatedOrder.stock ?? null);
+      if (newStockId) storage.set(KEY_STOCK_ID, newStockId, { maxAge: YEAR_SECONDS });
+      else storage.remove(KEY_STOCK_ID);
+      if (profileStore.store && profileStore.city) {
+        const remoteCatalog = getRemoteCatalog(
+          profileStore.store,
+          profileStore.city,
+          updatedOrder.stock ?? null
+        );
+        if (remoteCatalog && remoteCatalog.hash !== catalogStore.currentHash && catalogReloader) {
+          await catalogReloader.reload(profileStore.store.id, remoteCatalog);
+        }
+      }
+      if (cartStore.hasCredentials) {
+        await checkCartProducts();
+      }
+    } catch (e) {
+      logCartError(
+        {
+          scope: "stock-change",
+          context: { currentStockId, newStockId }
+        },
+        e
+      );
+      notifier.warning("\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0434\u043B\u044F \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u043E\u0433\u043E \u0441\u043A\u043B\u0430\u0434\u0430");
+    }
+  }
+  async function checkCartProducts() {
+    try {
+      const storeId = credentials.getStoreId();
+      const orderCredentials = credentials.getCredentials();
+      const result = await sdk.orders.checkProducts(storeId, orderCredentials);
+      if (result.action === OrderCartCheckerResultAction.Cleanup) {
+        const freshOrder = await sdk.orders.getOrder(storeId, orderCredentials, ORDER_WITH);
+        cartStore.setOrder(freshOrder);
+        await fetchTotal();
+        notifier.warning("\u041D\u0435\u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u0442\u043E\u0432\u0430\u0440\u044B \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0438 \u0431\u044B\u043B\u0438 \u0443\u0434\u0430\u043B\u0435\u043D\u044B \u0438\u0437 \u043A\u043E\u0440\u0437\u0438\u043D\u044B");
+      } else if (result.order_variants.length > 0) {
+        await fetchTotal();
+        notifier.warning("\u0426\u0435\u043D\u044B \u043D\u0435\u043A\u043E\u0442\u043E\u0440\u044B\u0445 \u0442\u043E\u0432\u0430\u0440\u043E\u0432 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u044B");
+      }
+    } catch (e) {
+      logCartError(
+        {
+          scope: "stock-products-check",
+          context: { orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+      notifier.warning("\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E\u0441\u0442\u044C \u0442\u043E\u0432\u0430\u0440\u043E\u0432 \u0432 \u043A\u043E\u0440\u0437\u0438\u043D\u0435");
+    }
+  }
+  return { handleStockChange };
+}
+
+// src/cart/useOrderDelivery.ts
+function useOrderDelivery(deps = {}) {
+  const runtime = useRuntime();
+  const activity = deps.activity ?? runtime.activity;
+  const notifier = deps.notifier ?? runtime.notifier;
+  const { sdk } = runtime;
+  const cartStore = useCartStore();
+  const credentials = useCartCredentials();
+  const { handleStockChange } = useCartStockWatcher();
+  const { fetchSettings } = useOrderSettings();
+  const { recalculateAfterOrderChange } = useCartRecalculation({
+    notifier,
+    activity
+  });
+  const { run: runMutation } = useCartMutation();
+  function hasCredentials() {
+    return Boolean(cartStore.credentials?.id && cartStore.credentials?.token);
+  }
+  async function settleAfter(options) {
+    await runMutation({ kind: "delivery-settle" }, async (isStale) => {
+      activity.begin("delivery");
+      try {
+        const storeId = credentials.getStoreId();
+        const orderCredentials = credentials.getCredentials();
+        const freshOrder = await sdk.orders.getOrder(storeId, orderCredentials, ORDER_WITH);
+        if (isStale()) return;
+        cartStore.setOrder(freshOrder);
+        await fetchSettings();
+        if (isStale()) return;
+        await recalculateAfterOrderChange();
+        if (options.withStockChange) {
+          if (options.awaitStockChange) await handleStockChange(freshOrder);
+          else void handleStockChange(freshOrder);
+        }
+      } catch (e) {
+        if (!isStale()) {
+          logCartError(
+            {
+              scope: "delivery-settle",
+              context: { orderId: cartStore.credentials?.id }
+            },
+            e
+          );
+        }
+      } finally {
+        activity.end("delivery");
+      }
+    });
+  }
+  async function setDelivery(request, options = {}) {
+    const awaitSettle = options.awaitSettle ?? false;
+    if (!hasCredentials()) {
+      return { ok: false, error: new Error("cart:no_credentials") };
+    }
+    const finalRequest = request.deliver_at === void 0 && cartStore.deliveryTimeIntent ? { ...request, deliver_at: cartStore.deliveryTimeIntent } : request;
+    try {
+      await runMutation({ kind: "delivery" }, async (isStale) => {
+        const storeId = credentials.getStoreId();
+        const orderCredentials = credentials.getCredentials();
+        await sdk.orders.setOrderDeliveryMethod(storeId, orderCredentials, finalRequest);
+        if (isStale()) return;
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "delivery",
+          context: {
+            method: request.delivery_method,
+            stockId: request.stock_id,
+            addressId: typeof request.delivery_address === "object" && request.delivery_address !== null && "id" in request.delivery_address ? request.delivery_address.id : void 0,
+            table: request.on_premise?.table,
+            orderId: cartStore.credentials?.id
+          }
+        },
+        e
+      );
+      return { ok: false, error: e };
+    }
+    const settlePromise = settleAfter({ withStockChange: true, awaitStockChange: awaitSettle });
+    if (awaitSettle) await settlePromise;
+    return { ok: true, value: void 0 };
+  }
+  async function runIntervalMutation(apiCall, errorContext, awaitSettle) {
+    if (!hasCredentials()) {
+      return { ok: false, error: new Error("cart:no_credentials") };
+    }
+    try {
+      await runMutation({ kind: "delivery" }, async (isStale) => {
+        await apiCall();
+        if (isStale()) return;
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "delivery",
+          context: { ...errorContext, orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+      return { ok: false, error: e };
+    }
+    const settlePromise = settleAfter({ withStockChange: false, awaitStockChange: awaitSettle });
+    if (awaitSettle) await settlePromise;
+    return { ok: true, value: void 0 };
+  }
+  async function setDeliveryInterval(selection, options = {}) {
+    return runIntervalMutation(
+      () => {
+        const storeId = credentials.getStoreId();
+        const orderCredentials = credentials.getCredentials();
+        return sdk.orders.setOrderDeliveryInterval(storeId, orderCredentials, {
+          date: selection.date,
+          interval_id: selection.id
+        });
+      },
+      { intervalDate: selection.date, intervalId: selection.id },
+      options.awaitSettle ?? false
+    );
+  }
+  async function resetDeliveryInterval(options = {}) {
+    return runIntervalMutation(
+      () => {
+        const storeId = credentials.getStoreId();
+        const orderCredentials = credentials.getCredentials();
+        return sdk.orders.resetOrderDeliveryInterval(storeId, orderCredentials);
+      },
+      {},
+      options.awaitSettle ?? false
+    );
+  }
+  async function setDeliveryTime(deliverAt, options = {}) {
+    return runIntervalMutation(
+      () => {
+        const storeId = credentials.getStoreId();
+        const orderCredentials = credentials.getCredentials();
+        if (typeof orderCredentials === "string") {
+          throw new Error("cart:no_credentials");
+        }
+        const path = sdk.client.getStoreUrl(
+          storeId,
+          `/orders/${orderCredentials.id}/checkout/delivery/time`,
+          { token: orderCredentials.token }
+        );
+        return sdk.client.request(
+          "POST",
+          path,
+          { deliver_at: deliverAt },
+          orderCredentials.api_token ?? null
+        );
+      },
+      { deliverAt },
+      options.awaitSettle ?? false
+    );
+  }
+  return {
+    setDelivery,
+    setDeliveryInterval,
+    resetDeliveryInterval,
+    setDeliveryTime
+  };
+}
+function useOrderPromocode(deps = {}) {
+  const runtime = useRuntime();
+  const { sdk } = runtime;
+  const activity = deps.activity ?? runtime.activity;
+  const notifier = deps.notifier ?? runtime.notifier;
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { recalculateAfterOrderChange } = useCartRecalculation({
+    notifier,
+    activity
+  });
+  const { run: runMutation } = useCartMutation();
+  const loading = ref(false);
+  const errorMessage = ref(null);
+  const applied = computed(() => cartStore.order?.promocode ?? null);
+  const isApplied = computed(() => applied.value !== null);
+  function clearError() {
+    errorMessage.value = null;
+  }
+  async function refreshOrder() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    try {
+      const orderCredentials = credentials.getCredentials();
+      const fresh = await sdk.orders.getOrder(storeId, orderCredentials, ORDER_WITH);
+      cartStore.setOrder(fresh);
+    } catch (e) {
+      logCartError(
+        {
+          scope: "promocode-refresh-order",
+          context: { orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+    }
+  }
+  async function apply(code) {
+    const trimmed = code.trim();
+    if (!trimmed) return;
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    errorMessage.value = null;
+    loading.value = true;
+    try {
+      await runMutation({ kind: "promocode" }, async (isStale) => {
+        activity.begin("promocode");
+        try {
+          const orderCredentials = credentials.getCredentials();
+          await sdk.orders.setOrderPromocode(storeId, orderCredentials, {
+            promocode: trimmed
+          });
+          if (isStale()) return;
+          await refreshOrder();
+          await recalculateAfterOrderChange();
+        } finally {
+          activity.end("promocode");
+        }
+      });
+    } catch (e) {
+      errorMessage.value = getCartErrorMessage(e, "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442\u044C \u043F\u0440\u043E\u043C\u043E\u043A\u043E\u0434");
+      logCartError(
+        {
+          scope: "promocode-apply",
+          context: { code: trimmed, orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function remove() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return;
+    if (!cartStore.credentials?.id) return;
+    errorMessage.value = null;
+    loading.value = true;
+    try {
+      await runMutation({ kind: "promocode" }, async (isStale) => {
+        activity.begin("promocode");
+        try {
+          const orderCredentials = credentials.getCredentials();
+          await sdk.orders.removeOrderPromocode(storeId, orderCredentials);
+          if (isStale()) return;
+          await refreshOrder();
+          await recalculateAfterOrderChange();
+        } finally {
+          activity.end("promocode");
+        }
+      });
+    } catch (e) {
+      errorMessage.value = getCartErrorMessage(e, "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0443\u0431\u0440\u0430\u0442\u044C \u043F\u0440\u043E\u043C\u043E\u043A\u043E\u0434");
+      logCartError(
+        {
+          scope: "promocode-remove",
+          context: {
+            code: applied.value?.promocode,
+            orderId: cartStore.credentials?.id
+          }
+        },
+        e
+      );
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    applied,
+    isApplied,
+    loading,
+    errorMessage,
+    apply,
+    remove,
+    clearError
+  };
+}
+function useCartDeliveryAttachment() {
+  const { sdk } = useRuntime();
+  const cartStore = useCartStore();
+  const orderSettings = useOrderSettingsStore();
+  const profileStore = useStoreProfileStore();
+  const authStore = useAuthStore();
+  const { setDelivery } = useOrderDelivery();
+  async function recoverDeliveryAddress() {
+    const selected = orderSettings.selectedAddress;
+    const storeId = profileStore.store?.id;
+    if (!selected || !storeId || !authStore.isAuthenticated) return false;
+    let addresses;
+    try {
+      const response = await sdk.customer.getAddresses(storeId);
+      addresses = response.items ?? [];
+    } catch {
+      return false;
+    }
+    const target = normalizeAddress(selected);
+    const match = addresses.find((a) => normalizeAddress(a.address) === target);
+    if (!match) return false;
+    const result = await setDelivery({
+      delivery_method: DeliveryMethod.Delivery,
+      delivery_address: { id: match.id }
+    });
+    if (!result.ok) return false;
+    orderSettings.setSelectedAddress(match.address, match.id, match.name);
+    return true;
+  }
+  async function reattachDelivery() {
+    const order = cartStore.order;
+    if (!order) return;
+    let result = null;
+    switch (orderSettings.deliveryMethod) {
+      case DeliveryMethod.Delivery: {
+        if (order.delivery_address) return;
+        const addressId = orderSettings.selectedAddressId;
+        if (!addressId) {
+          const recovered = await recoverDeliveryAddress();
+          if (!recovered && orderSettings.selectedAddress) {
+            orderSettings.setSelectedAddress(null, null, null);
+          }
+          return;
+        }
+        result = await setDelivery({
+          delivery_method: DeliveryMethod.Delivery,
+          delivery_address: { id: addressId }
+        });
+        break;
+      }
+      case DeliveryMethod.Pickup: {
+        if (order.stock) return;
+        const stock = orderSettings.selectedStock;
+        if (!stock) return;
+        result = await setDelivery({
+          delivery_method: DeliveryMethod.Pickup,
+          stock_id: stock.id
+        });
+        break;
+      }
+      case DeliveryMethod.OnPremise: {
+        if (order.stock) return;
+        const stock = orderSettings.selectedStock;
+        if (!stock) return;
+        result = await setDelivery({
+          delivery_method: DeliveryMethod.OnPremise,
+          stock_id: stock.id,
+          on_premise: { table: orderSettings.onPremiseTable ?? "" }
+        });
+        break;
+      }
+    }
+    if (result && !result.ok) {
+      if (getCartErrorCode(result.error) === "addresses.not_found") {
+        const recovered = await recoverDeliveryAddress();
+        if (!recovered) orderSettings.setSelectedAddress(null, null, null);
+        return;
+      }
+      console.error("[cart-delivery-attach] failed", result.error);
+    }
+  }
+  watch(
+    () => cartStore.order?.id,
+    async (newId, oldId) => {
+      if (!newId || newId === oldId) return;
+      await reattachDelivery();
+    }
+  );
+}
+
+// src/cart/useCartOperations.ts
+var RUM_MARK_CART_ADD = "rum:cart:add";
+var RUM_MARK_CART_REMOVE = "rum:cart:remove";
+var RUM_METRIC_CART_ADD = "rum_cart_add_seconds";
+var RUM_METRIC_CART_REMOVE = "rum_cart_remove_seconds";
+var BATCH_DELAY = 250;
+var CART_LINE_KIND_PREFIX = "cart-line-";
+var getOperationsState = createRuntimeState(() => ({
+  batches: /* @__PURE__ */ new Map(),
+  inflight: /* @__PURE__ */ new Set()
+}));
+function useCartOperations(credentials, initialization, sdk, deps) {
+  const { notifier, activity } = deps;
+  const runtime = useRuntime();
+  const { events, rum, commerceEvents } = runtime;
+  const { batches, inflight } = getOperationsState(runtime);
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const { run: runMutation, bumpKindsWithPrefix } = useCartMutation();
+  const { recalculateAfterOrderChange } = useCartRecalculation({ notifier, activity });
+  function flushBatch(lineKey) {
+    if (inflight.has(lineKey)) return;
+    const batch = batches.get(lineKey);
+    if (!batch) return;
+    batches.delete(lineKey);
+    if (batch.delta === 0) {
+      activity.end("cart");
+      return;
+    }
+    inflight.add(lineKey);
+    const sentDelta = batch.delta;
+    const isAdd = sentDelta > 0;
+    const qty = Math.abs(sentDelta);
+    const { variantId, productId, productName, variantLabel } = batch;
+    const execute = async () => {
+      const kind = `${CART_LINE_KIND_PREFIX}${lineKey}`;
+      let optimisticCorrected = false;
+      try {
+        await runMutation({ kind }, async (isStale) => {
+          const orderCredentials = credentials.getCredentials();
+          const storeId = credentials.getStoreId();
+          const wasInCartBefore = cartStore.order?.variants?.some((v) => variantLineKey(v) === lineKey) ?? false;
+          const variantBeforeChange = !isAdd ? cartStore.order?.variants?.find((v) => variantLineKey(v) === lineKey) ?? null : null;
+          if (isAdd) {
+            rum?.mark(RUM_MARK_CART_ADD);
+            const updatedOrder = await sdk.orders.addProductVariantToOrder(
+              storeId,
+              orderCredentials,
+              {
+                product_variant_id: variantId,
+                quantity: qty,
+                modifiers: batch.modifiers
+              }
+            );
+            rum?.measure(RUM_METRIC_CART_ADD, RUM_MARK_CART_ADD);
+            if (isStale()) return;
+            cartStore.patchOrder(updatedOrder);
+            credentials.persistCredentials(updatedOrder);
+          } else {
+            const removeRequest = {
+              product_variant_id: variantId,
+              quantity: qty,
+              modifiers: batch.modifiers,
+              ...batch.promotionId ? {
+                promotion_id: batch.promotionId,
+                promotion_reward_id: batch.promotionRewardId
+              } : {}
+            };
+            rum?.mark(RUM_MARK_CART_REMOVE);
+            const updatedOrder = await sdk.orders.removeProductVariantFromOrder(
+              storeId,
+              orderCredentials,
+              removeRequest
+            );
+            rum?.measure(RUM_METRIC_CART_REMOVE, RUM_MARK_CART_REMOVE);
+            if (isStale()) return;
+            cartStore.patchOrder(updatedOrder);
+          }
+          cartStore.adjustOptimistic(productId, -sentDelta);
+          cartStore.adjustLineOptimistic(lineKey, -sentDelta);
+          optimisticCorrected = true;
+          const integrations = events?.get() ?? null;
+          const orderVariant = cartStore.order?.variants?.find((v) => variantLineKey(v) === lineKey) ?? null;
+          if (isAdd) {
+            if (!wasInCartBefore) {
+              integrations?.productAddedToCart({
+                order: cartStore.order,
+                orderVariant
+              });
+            } else {
+              integrations?.productQuantityIncreased({
+                order: cartStore.order,
+                orderVariant
+              });
+            }
+          } else {
+            const isNowInCart = cartStore.order?.variants?.some((v) => variantLineKey(v) === lineKey) ?? false;
+            if (!isNowInCart) {
+              const product = variantBeforeChange?.product ?? null;
+              integrations?.productRemovedFromCart({
+                order: cartStore.order,
+                product
+              });
+            } else {
+              integrations?.productQuantityDecreased({
+                order: cartStore.order,
+                orderVariant
+              });
+            }
+          }
+          const commerceOrderId = cartStore.credentials?.id;
+          if (commerceOrderId && commerceEvents) {
+            if (isAdd) {
+              const currency = profileStore.currency;
+              const cartTotal = cartStore.order?.total_price;
+              commerceEvents.trackAddedToCart(commerceOrderId, {
+                productId,
+                productVariantId: variantId,
+                quantity: qty,
+                unitPrice: orderVariant ? minorToMajor(orderVariant.unit_price, currency) : void 0,
+                totalPrice: cartTotal != null ? minorToMajor(cartTotal, currency) : void 0
+              });
+            } else {
+              commerceEvents.trackRemovedFromCart(commerceOrderId, {
+                productId,
+                productVariantId: variantId,
+                quantity: qty
+              });
+            }
+          }
+          await recalculateAfterOrderChange();
+          if (isAdd && productName) {
+            const parts = [productName, variantLabel].filter(Boolean);
+            notifier.message("\u0414\u043E\u0431\u0430\u0432\u043B\u0435\u043D\u043E:", { description: parts.join(", ") });
+          }
+        });
+      } catch (e) {
+        logCartError(
+          {
+            scope: isAdd ? "cart-add" : "cart-remove",
+            context: {
+              lineKey,
+              variantId,
+              productId,
+              qty,
+              modifiers: batch.modifiers?.length ?? 0,
+              promotionId: batch.promotionId,
+              orderId: cartStore.credentials?.id
+            }
+          },
+          e
+        );
+        const integrations = events?.get() ?? null;
+        if (isAdd) {
+          integrations?.productQuantityIncreaseFailed({ order: cartStore.order });
+        } else {
+          integrations?.productQuantityDecreaseFailed({ order: cartStore.order });
+        }
+        notifier.error(getCartErrorMessage(e, "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u044C \u043A\u043E\u0440\u0437\u0438\u043D\u0443"));
+        try {
+          await refreshCart({ silent: true });
+        } catch (refreshErr) {
+          logCartError(
+            { scope: "cart-refresh-after-fail", context: { lineKey, variantId } },
+            refreshErr
+          );
+        }
+      } finally {
+        if (!optimisticCorrected) {
+          cartStore.adjustOptimistic(productId, -sentDelta);
+          cartStore.adjustLineOptimistic(lineKey, -sentDelta);
+        }
+        activity.end("cart");
+        inflight.delete(lineKey);
+        if (batches.has(lineKey)) flushBatch(lineKey);
+      }
+    };
+    execute();
+  }
+  function enqueueDelta(request, delta) {
+    const lineKey = buildCartLineKey({
+      productVariantId: request.productVariantId,
+      modifiers: request.modifiers,
+      promotionId: request.promotionId,
+      promotionRewardId: request.promotionRewardId
+    });
+    cartStore.adjustOptimistic(request.productId, delta);
+    cartStore.adjustLineOptimistic(lineKey, delta);
+    const existing = batches.get(lineKey);
+    if (existing) {
+      clearTimeout(existing.timer);
+      existing.delta += delta;
+      existing.timer = setTimeout(() => flushBatch(lineKey), BATCH_DELAY);
+      return;
+    }
+    activity.begin("cart");
+    const timer = setTimeout(() => flushBatch(lineKey), BATCH_DELAY);
+    batches.set(lineKey, {
+      lineKey,
+      variantId: request.productVariantId,
+      productId: request.productId,
+      delta,
+      modifiers: request.modifiers,
+      promotionId: request.promotionId,
+      promotionRewardId: request.promotionRewardId,
+      productName: request.productName,
+      variantLabel: request.variantLabel,
+      timer
+    });
+  }
+  async function addToCart(request) {
+    if (cartStore.initializing || !cartStore.hasCredentials) {
+      throw new Error("cart:not_ready");
+    }
+    enqueueDelta(request, request.quantity ?? 1);
+  }
+  async function removeFromCart(request) {
+    if (!cartStore.hasCredentials) return;
+    enqueueDelta(request, -(request.quantity ?? 1));
+  }
+  async function refreshCart(options) {
+    if (!cartStore.hasCredentials) return;
+    const silent = options?.silent ?? false;
+    if (!silent) {
+      cartStore.setLoading(true);
+    }
+    try {
+      const orderCredentials = credentials.getCredentials();
+      const storeId = credentials.getStoreId();
+      const freshOrder = await sdk.orders.getOrder(storeId, orderCredentials, ORDER_WITH);
+      cartStore.setOrder(freshOrder);
+    } catch (e) {
+      logCartError(
+        {
+          scope: "cart-refresh",
+          context: { orderId: cartStore.credentials?.id, silent }
+        },
+        e
+      );
+      cartStore.clearCart();
+      credentials.clearPersistedCredentials();
+    } finally {
+      if (!silent) {
+        cartStore.setLoading(false);
+      }
+    }
+  }
+  function cancelPendingCartMutations() {
+    for (const batch of batches.values()) clearTimeout(batch.timer);
+    batches.clear();
+    inflight.clear();
+    bumpKindsWithPrefix(CART_LINE_KIND_PREFIX);
+    activity.end("cart");
+  }
+  function clearAndResetCart() {
+    cancelPendingCartMutations();
+    credentials.clearPersistedCredentials();
+    cartStore.clearCart();
+    initialization.initializeOrder().catch((e) => {
+      logCartError({ scope: "cart-reinit" }, e);
+    });
+  }
+  return {
+    addToCart,
+    removeFromCart,
+    refreshCart,
+    clearAndResetCart
+  };
+}
+function useCheckoutSubmit(getRecaptchaPayload) {
+  const { sdk, activity, events, commerceEvents } = useRuntime();
+  const credentials = useCartCredentials();
+  const cartStore = useCartStore();
+  const profileStore = useStoreProfileStore();
+  const result = ref(null);
+  const submitting = ref(false);
+  async function runBusy(fn) {
+    activity.begin("custom");
+    try {
+      return await fn();
+    } finally {
+      activity.end("custom");
+    }
+  }
+  async function submit() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return null;
+    if (!cartStore.credentials?.id) return null;
+    submitting.value = true;
+    try {
+      return await runBusy(async () => {
+        const orderCredentials = credentials.getCredentials();
+        const recaptcha = await getRecaptchaPayload(RecaptchaAction.OrderSubmission);
+        const integrations = events?.get() ?? null;
+        const analyticsData = integrations ? await integrations.analytics.getAll() : null;
+        const request = {
+          notes: cartStore.comment || void 0,
+          persons_count: cartStore.personsCount,
+          recaptcha,
+          ...commerceEvents?.getIdentity() ?? {},
+          ...analyticsData?.length ? { analytics_data: analyticsData } : {}
+        };
+        const cartVariants = cartStore.order?.variants ?? [];
+        const res = await sdk.orders.checkoutOrder(storeId, orderCredentials, request);
+        const orderForEvent = { ...res.order, variants: res.order.variants ?? cartVariants };
+        integrations?.orderSubmitted({ order: orderForEvent });
+        result.value = res;
+        return res;
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "checkout-submit",
+          context: {
+            orderId: cartStore.credentials?.id,
+            notes: cartStore.comment ? cartStore.comment.length : 0,
+            personsCount: cartStore.personsCount
+          }
+        },
+        e
+      );
+      throw e;
+    } finally {
+      submitting.value = false;
+    }
+  }
+  async function confirm(code) {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return false;
+    if (!cartStore.credentials?.id) return false;
+    try {
+      return await runBusy(async () => {
+        const orderCredentials = credentials.getCredentials();
+        return await sdk.orders.confirmOrder(storeId, orderCredentials, { code });
+      });
+    } catch (e) {
+      logCartError(
+        {
+          scope: "checkout-confirm",
+          context: { orderId: cartStore.credentials?.id, codeLength: code.length }
+        },
+        e
+      );
+      throw e;
+    }
+  }
+  async function resendCode() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return false;
+    if (!cartStore.credentials?.id) return false;
+    try {
+      const orderCredentials = credentials.getCredentials();
+      return await sdk.orders.resendOrderConfirmationCode(storeId, orderCredentials);
+    } catch (e) {
+      logCartError(
+        {
+          scope: "checkout-resend-code",
+          context: { orderId: cartStore.credentials?.id }
+        },
+        e
+      );
+      throw e;
+    }
+  }
+  async function cancel() {
+    const storeId = profileStore.store?.id;
+    if (!storeId) return false;
+    if (!cartStore.credentials?.id) return false;
+    try {
+      const orderCredentials = credentials.getCredentials();
+      const ok = await sdk.orders.cancelOrder(storeId, orderCredentials);
+      if (ok) {
+        result.value = null;
+        credentials.clearPersistedCredentials();
+        cartStore.clearCart();
+      }
+      return ok;
+    } catch (e) {
+      logCartError(
+        { scope: "checkout-cancel", context: { orderId: cartStore.credentials?.id } },
+        e
+      );
+      throw e;
+    }
+  }
+  return { result, submitting, submit, confirm, resendCode, cancel };
+}
+function useStorefrontCart() {
+  const { sdk, notifier, activity } = useRuntime();
+  const cartStore = useCartStore();
+  const { order, loading, initializing } = storeToRefs(cartStore);
+  const variants = computed(() => cartStore.variants);
+  const itemCount = computed(() => cartStore.itemCount);
+  const totalPrice = computed(() => cartStore.totalPrice);
+  const hasOrder = computed(() => cartStore.hasOrder);
+  const credentials = useCartCredentials();
+  const { getProductQuantity, getVariantQuantity } = useCartQuantities();
+  const { initializeOrder } = useCartInitialization(credentials, sdk);
+  const { addToCart, removeFromCart, refreshCart, clearAndResetCart } = useCartOperations(
+    credentials,
+    { initializeOrder },
+    sdk,
+    { notifier, activity }
+  );
+  const { recalculateAfterOrderChange } = useCartRecalculation({ notifier, activity });
+  return {
+    order,
+    variants,
+    itemCount,
+    totalPrice,
+    loading,
+    initializing,
+    hasOrder,
+    getProductQuantity,
+    getVariantQuantity,
+    initializeOrder,
+    addToCart,
+    removeFromCart,
+    refreshCart,
+    clearAndResetCart,
+    recalculate: recalculateAfterOrderChange
+  };
+}
+
+// src/cart/useOrderChannel.ts
+var getOrderChannelState = createRuntimeState(() => ({
+  currentChannel: null,
+  currentChannelName: null,
+  initialized: false,
+  priceReconcileTimer: null
+}));
+function useOrderChannel() {
+  const runtime = useRuntime();
+  const state = getOrderChannelState(runtime);
+  if (state.initialized) return;
+  const { realtime, notifier, events } = runtime;
+  const resolvedRealtime = realtime?.get() ?? null;
+  if (!resolvedRealtime) return;
+  const rt = resolvedRealtime;
+  state.initialized = true;
+  const cartStore = useCartStore();
+  const promotionsStore = usePromotionsStore();
+  const { refreshCart } = useStorefrontCart();
+  const { fetchTotal } = useOrderTotal();
+  const { reconcileAfterOrderChange } = useBonusesReconciliation({ notifier });
+  function getChannelName() {
+    const creds = cartStore.credentials;
+    if (!creds?.id || !creds?.token) return null;
+    return `orders.${creds.id}.${creds.token}`;
+  }
+  function subscribeToOrder() {
+    const channelName = getChannelName();
+    if (channelName === state.currentChannelName) return;
+    if (state.currentChannelName) {
+      rt.unsubscribe(state.currentChannelName);
+      state.currentChannel = null;
+      state.currentChannelName = null;
+    }
+    if (!channelName) return;
+    state.currentChannel = rt.subscribe(channelName);
+    state.currentChannelName = channelName;
+    if (!state.currentChannel) return;
+    state.currentChannel.bind(ORDER_EVENTS.PriceRecalculated, () => {
+      events?.get()?.orderPriceRecalculated({ order: cartStore.order });
+      if (state.priceReconcileTimer) clearTimeout(state.priceReconcileTimer);
+      state.priceReconcileTimer = setTimeout(() => {
+        state.priceReconcileTimer = null;
+        void fetchTotal().then(() => reconcileAfterOrderChange());
+      }, 150);
+    });
+    state.currentChannel.bind(ORDER_EVENTS.Reload, () => {
+      events?.get()?.orderShouldBeReloaded({ order: cartStore.order });
+      void refreshCart({ silent: true }).then(() => fetchTotal());
+    });
+    state.currentChannel.bind(ORDER_EVENTS.Repeated, () => {
+    });
+    state.currentChannel.bind(ORDER_EVENTS.PromotionsNotFound, () => {
+      const integrations = events?.get() ?? null;
+      integrations?.orderPromotionsNotFound({ order: cartStore.order });
+      integrations?.promotionsCheckerCompleted({ order: cartStore.order });
+      promotionsStore.setChecking(false);
+      promotionsStore.clearRewards();
+    });
+    state.currentChannel.bind(ORDER_EVENTS.RewardsDisplaySelection, (data) => {
+      if (!data || typeof data !== "object") return;
+      const payload = data;
+      if (typeof payload.promotion_id === "string" && typeof payload.reward_id === "string") {
+        const integrations = events?.get() ?? null;
+        integrations?.displayOrderPromotionRewardSelection({
+          order: cartStore.order,
+          selection: payload
+        });
+        integrations?.promotionsCheckerCompleted({ order: cartStore.order });
+        promotionsStore.setChecking(false);
+        promotionsStore.addOrUpdateReward({
+          offerId: payload.offer?.id ?? "",
+          promotionId: payload.promotion_id,
+          rewardId: payload.reward_id,
+          context: payload.context?.type != null && payload.context?.id != null ? { type: payload.context.type, id: payload.context.id } : null,
+          limit: payload.limit ?? 1
+        });
+      }
+    });
+    state.currentChannel.bind(ORDER_EVENTS.RewardsReload, () => {
+      events?.get()?.orderPromotionRewardsShouldBeReloaded({
+        order: cartStore.order
+      });
+      void refreshCart({ silent: true }).then(() => fetchTotal());
+    });
+  }
+  watchEffect(() => {
+    if (rt.isReady.value) {
+      subscribeToOrder();
+    }
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      if (state.priceReconcileTimer) {
+        clearTimeout(state.priceReconcileTimer);
+        state.priceReconcileTimer = null;
+      }
+      if (state.currentChannelName) {
+        rt.unsubscribe(state.currentChannelName);
+      }
+      state.currentChannel = null;
+      state.currentChannelName = null;
+      state.initialized = false;
+    });
+  }
+}
+
+export { CASH_DENOMINATIONS_MAJOR, DEFAULT_ROUND_STEPS_MAJOR, ORDER_EVENTS, ORDER_WITH, buildCartLineKey, buildCashChangePresets, buildMainPaymentRequest, getCartErrorCode, getCartErrorHttpCode, getCartErrorMessage, getCashDenominationsMinor, getDefaultRoundStepsMinor, getValidationErrors, logCartError, normalizeAddress, useBonusesReconciliation, useCartAddressSync, useCartCustomerAttachment, useCartDeliveryAttachment, useCartInitialization, useCartMutation, useCartOperations, useCartQuantities, useCartRecalculation, useCartStockWatcher, useCheckoutFlow, useCheckoutSubmit, useCustomerAttach, useOnlinePaymentRetry, useOrderBonuses, useOrderChannel, useOrderDelivery, useOrderPromocode, useOrderSettings, useOrderTotal, usePaymentSelection, useStorefrontCart, variantLineKey };
+//# sourceMappingURL=chunk-OQLU7FSR.js.map
+//# sourceMappingURL=chunk-OQLU7FSR.js.map