@pisell/pisellos 0.0.568 → 0.0.569

package/lib/modules/Order/index.js

@@ -5,15 +5,53 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.OrderModule = void 0;
 var _BaseModule = require("../BaseModule");
+var _types = require("./types");
 var _utils = require("./utils");
 var _utils2 = require("../Product/utils");
 var _dayjs = _interopRequireDefault(require("dayjs"));
+var _cartPromotion = require("../../solution/BaseSales/utils/cartPromotion");
 var _utils3 = require("../../solution/ScanOrder/utils");
+var _manualProductDiscount = require("./utils/manualProductDiscount");
+var _bundleDiscountHydration = require("./utils/bundleDiscountHydration");
+var _orderCollectionIdentity = require("./utils/orderCollectionIdentity");
 var _Discount = require("../Discount");
 var _Rules = require("../Rules");
-var _types = require("../Rules/types");
+var _types2 = require("../Rules/types");
 var _decimal = _interopRequireDefault(require("decimal.js"));
+var _lodashEs = require("lodash-es");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function normalizeDiscountListSignature(discountList) {
+  return (discountList || []).map(item => ({
+    type: item?.type ?? '',
+    discount_id: item?.discount_id ?? null,
+    order_discount_id: item?.order_discount_id ?? null,
+    amount: new _decimal.default(Number(item?.amount) || 0).toFixed(2)
+  }));
+}
+function isSameDiscountList(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  return JSON.stringify(normalizeDiscountListSignature(left)) === JSON.stringify(normalizeDiscountListSignature(right));
+}
+function isManualProductDiscountProduct(product) {
+  return product?.metadata?.is_manual_discount === true || product?.metadata?.is_manual_discount === 1 || (product?.discount_list || []).some(item => item?.type === 'product');
+}
+const ORDER_PAYMENT_STATUS_PAID = 'paid';
+const ORDER_PAYMENT_STATUS_PENDING = 'payment_pending';
+function isVoucherPaymentRecord(payment) {
+  return payment?.voucher_id !== undefined && Number(payment.voucher_id) !== 0;
+}
+function hasSyncedOrderPaymentRecord(payment) {
+  return payment?.order_payment_id !== undefined && payment.order_payment_id !== null;
+}
+function isPendingVoucherPaymentRecord(payment) {
+  return isVoucherPaymentRecord(payment) && payment?.status === ORDER_PAYMENT_STATUS_PENDING;
+}
+function isPaidPaymentRecord(payment) {
+  return payment?.status === ORDER_PAYMENT_STATUS_PAID;
+}
+function isCommittedVoucherPaymentRecord(payment) {
+  return isVoucherPaymentRecord(payment) && payment?.status !== 'voided' && (hasSyncedOrderPaymentRecord(payment) || isPaidPaymentRecord(payment));
+}
 class OrderModule extends _BaseModule.BaseModule {
   defaultName = 'order';
   defaultVersion = '1.0.0';
@@ -24,6 +62,114 @@ class OrderModule extends _BaseModule.BaseModule {
   cacheId;
   salesSummaryModuleName;
   rulesHooksOverride;
+  moduleHooksOverride;
+  orderHooks;
+  otherParams;
+  // ─── 促销/赠品 ────────────────────────────────────
+  /** 评估器引用；由 SalesSdkProvider 注入，未注入时 applyPromotion 静默跳过 */
+  promotionEvaluator = null;
+  /** 赠品选择 resolver；由 SDK host bridge 注入 */
+  giftSelectResolver = null;
+  /** applyPromotion 递归保护 flag（写路径同步调 applyPromotion，禁止重入） */
+  isApplyingPromotion = false;
+  /** 商品曾应用过客户券卡，客户变更剥离后需强制跑一次 calcDiscount 复位价格 */
+  hasActiveCustomerBoundDiscount = false;
+  /** 最近一次 applyPromotion 的未满足促销提示 */
+  lastUnfulfilledPromotions = [];
+  /** 最近一次 applyPromotion 的赠品操作 diff（debug / SDK 读取使用） */
+  lastGiftActions = null;
+  /**
+   * 是否将 tempOrder 写入 IndexedDB 草稿（orders store）。
+   * BigSale 弹窗等短生命周期场景通过 setEnableTempOrderPersist(false) 关闭。
+   */
+  draftPersistEnabled = true;
+  collectHydratedEditDiscounts(products) {
+    const discountMap = new Map();
+    for (const product of (0, _bundleDiscountHydration.expandHydratedProductsForDiscountCollection)(products)) {
+      for (const item of product?.discount_list || []) {
+        const type = item?.type ?? item?.tag;
+        if (!type || type === 'product') continue;
+        const resourceId = item?.discount?.resource_id ?? item?.resource_id ?? item?.discount_id ?? item?.order_discount_id;
+        if (resourceId === undefined || resourceId === null || resourceId === '') continue;
+        const id = Number(resourceId);
+        const key = Number.isFinite(id) ? id : String(resourceId);
+        const title = item?.discount?.title ?? {};
+        const amount = Number(item?.amount || 0);
+        const detail = {
+          amount: String(item?.amount ?? '0'),
+          type,
+          resource_id: key,
+          title,
+          original_amount: String(item?.discount?.original_amount ?? item?.amount ?? '0'),
+          num: Number(item?.metadata?.num ?? product?.num ?? product?.product_quantity ?? 1) || 1,
+          metadata: item?.metadata,
+          discount: item?.discount,
+          _num: Number(item?.metadata?.num ?? product?.num ?? product?.product_quantity ?? 1) || 1
+        };
+        const existed = discountMap.get(key);
+        if (existed) {
+          existed.amount = Number(existed.amount || 0) + amount;
+          existed.used_par_value = String(Number(existed.used_par_value || 0) + amount);
+          existed.balance = String(Number(existed.balance || 0) + amount);
+          const productIds = Array.isArray(existed.limited_relation_product_data?.product_ids) ? existed.limited_relation_product_data.product_ids : [];
+          if (product?.product_id !== undefined && product?.product_id !== null && !productIds.includes(product.product_id)) {
+            existed.limited_relation_product_data = {
+              ...(existed.limited_relation_product_data || {}),
+              product_ids: [...productIds, product.product_id]
+            };
+          }
+          existed.applicableProductDetails = [...(existed.applicableProductDetails || []), detail];
+          existed.appliedProductDetails = [...(existed.appliedProductDetails || []), detail];
+          continue;
+        }
+        discountMap.set(key, {
+          id: key,
+          product_name: '',
+          encoded: '',
+          code: '',
+          tag: type,
+          product_id: item?.discount?.discount_product_id ?? product?.product_id ?? 0,
+          relation_type: '',
+          par_value: String(item?.discount?.original_amount ?? item?.amount ?? '0'),
+          used_par_value: String(item?.amount ?? '0'),
+          limit_status: 'enable',
+          limited_relation_product_data: {
+            id: 0,
+            type: 'products',
+            product_ids: [product?.product_id].filter(value => value !== undefined && value !== null),
+            product_collection_id: [],
+            filter: 0,
+            exclude_product_ids: []
+          },
+          balance: String(item?.amount ?? '0'),
+          format_title: title,
+          product: {
+            id: product?.product_id ?? 0,
+            title: '',
+            is_charge_tax: product?.is_charge_tax ?? 0,
+            base_price: String(product?.original_price ?? product?.selling_price ?? '0')
+          },
+          type,
+          resource_id: key,
+          isEditMode: true,
+          isSelected: true,
+          isAvailable: true,
+          isUsed: true,
+          isDisabled: true,
+          amount,
+          discount: {
+            ...(item?.discount || {}),
+            resource_id: key,
+            discount_product_id: item?.discount?.discount_product_id ?? product?.product_id ?? 0,
+            discount_calculation_mode: item?.discount?.discount_calculation_mode ?? 'item_level'
+          },
+          applicableProductDetails: [detail],
+          appliedProductDetails: [detail]
+        });
+      }
+    }
+    return Array.from(discountMap.values());
+  }
 
   /**
    * Populate `savedAmount` on each discount based on product-level discount details.
@@ -31,22 +177,79 @@ class OrderModule extends _BaseModule.BaseModule {
    */
   static populateSavedAmounts(productList, discountList) {
     const savedMap = new Map();
+    const editModeSavedMap = new Map();
+    const runtimeSavedMap = new Map();
+    const editModeDiscountKeys = new Set((discountList || []).filter(discount => discount?.isEditMode).map(discount => discount?.id).filter(id => id !== undefined && id !== null));
+    const addDiscountAmount = (targetMap, discountKey, amount) => {
+      targetMap.set(discountKey, (targetMap.get(discountKey) || new _decimal.default(0)).plus(amount));
+    };
+    const addProductDiscountAmount = (discount, quantity, isPersistedProduct) => {
+      const discountKey = discount.discount?.resource_id || discount.id;
+      if (discountKey == null) return;
+      const qty = Number(quantity) || 1;
+      const amount = new _decimal.default(discount.amount || 0).times(qty).plus(discount.metadata?.product_discount_difference || 0);
+      addDiscountAmount(savedMap, discountKey, amount);
+      addDiscountAmount(isPersistedProduct || discount.order_discount_id != null ? editModeSavedMap : runtimeSavedMap, discountKey, amount);
+    };
     for (const product of productList) {
       const qty = product.num || 1;
+      const isPersistedProduct = Boolean(product.order_detail_id || product.orderDetailId || product.booking_id);
       for (const pd of product.discount_list || []) {
-        const discountKey = pd.discount?.resource_id || pd.id;
-        if (discountKey == null) continue;
-        const amount = new _decimal.default(pd.amount || 0).times(qty).plus(pd.metadata?.product_discount_difference || 0);
-        savedMap.set(discountKey, (savedMap.get(discountKey) || new _decimal.default(0)).plus(amount));
+        addProductDiscountAmount(pd, qty, isPersistedProduct);
+      }
+      for (const bundle of product.product_bundle || []) {
+        const isPersistedBundleProduct = isPersistedProduct || Boolean(bundle?.order_detail_id || bundle?.orderDetailId || bundle?.booking_id);
+        const bundleQty = new _decimal.default(Number(qty) || 1).times(Number(bundle?.num ?? bundle?.quantity ?? 1) || 1).toNumber();
+        for (const pd of bundle?.discount_list || []) {
+          addProductDiscountAmount(pd, bundleQty, isPersistedBundleProduct);
+        }
       }
     }
     for (const d of discountList) {
       const key = d.id;
-      d.savedAmount = d.isSelected && key != null && savedMap.has(key) ? savedMap.get(key).toNumber() : 0;
+      const sourceMap = d.isEditMode ? editModeSavedMap : editModeDiscountKeys.has(key) ? runtimeSavedMap : savedMap;
+      d.savedAmount = d.isSelected && key != null && sourceMap.has(key) ? sourceMap.get(key).toNumber() : 0;
     }
   }
+  applyProductDiscountPrices(products) {
+    return (products || []).map(product => {
+      if (isManualProductDiscountProduct(product)) return product;
+      const discountItems = Array.isArray(product.discount_list) ? product.discount_list : [];
+      const hasOnlyPersistedDiscountSnapshots = product.order_detail_id !== undefined && product.order_detail_id !== null && discountItems.length > 0 && discountItems.every(discount => discount?.order_discount_id !== undefined && discount?.order_discount_id !== null);
+      if (hasOnlyPersistedDiscountSnapshots) {
+        return product;
+      }
+      const totalPerUnitDiscount = (0, _utils.resolveEffectivePerUnitDiscount)(product);
+      const optionSum = (0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(product));
+      const sourcePrice = product.metadata?.source_product_price ?? (product.metadata?.main_product_original_price != null ? new _decimal.default(Number(product.metadata.main_product_original_price) || 0).minus(optionSum).toFixed(2) : product.original_price ?? '0');
+      const newSourceSellingPrice = new _decimal.default(Number(sourcePrice) || 0).minus(totalPerUnitDiscount).toDecimalPlaces(2).toString();
+      const newMainSellingPrice = new _decimal.default(Number(newSourceSellingPrice) || 0).plus(optionSum).toDecimalPlaces(2).toFixed(2);
+      if (product.metadata) {
+        product.metadata.main_product_selling_price = newMainSellingPrice;
+        product.metadata.price_schema_version = 2;
+      }
+      if (Array.isArray(product.product_bundle)) {
+        product.product_bundle = product.product_bundle.map(bundle => {
+          const hasBundleDiscount = Array.isArray(bundle?.discount_list) && bundle.discount_list.length > 0;
+          if (hasBundleDiscount) return bundle;
+          const restoredPrice = bundle?.original_price ?? bundle?.product_price ?? bundle?.price;
+          if (restoredPrice === undefined || restoredPrice === null || restoredPrice === '') return bundle;
+          return {
+            ...bundle,
+            price: restoredPrice,
+            bundle_selling_price: restoredPrice
+          };
+        });
+      }
+      product.selling_price = (0, _utils.composeLinePrice)({
+        mainPrice: newMainSellingPrice,
+        bundle: product.product_bundle
+      });
+      return product;
+    });
+  }
   constructor(name, version) {
-    super(name || "order", version);
+    super(name || 'order', version);
   }
   async initialize(core, options) {
     this.core = core;
@@ -54,25 +257,66 @@ class OrderModule extends _BaseModule.BaseModule {
     if (!this.store.tempOrder) {
       this.store.tempOrder = null;
     }
+    if (!this.store.summary) {
+      this.store.summary = (0, _utils.createEmptySummary)();
+    }
     if (!Array.isArray(this.store.availableWalletIds)) {
       this.store.availableWalletIds = [];
     }
     this.request = this.core.getPlugin('request');
+    const appPlugin = this.core.getPlugin('app');
+    if (!appPlugin) {
+      console.error('Order 模块需要 app 插件支持');
+    }
+    const app = appPlugin?.getApp?.();
+    this.logger = app?.logger;
     this.window = this.core.getPlugin('window');
     const otherParams = options.otherParams || {};
     this.cacheId = otherParams.cacheId;
     this.salesSummaryModuleName = otherParams.salesSummaryModuleName;
     this.rulesHooksOverride = otherParams.rules?.hooks;
+    this.moduleHooksOverride = options.hooks;
+    this.orderHooks = this.moduleHooksOverride || otherParams.order?.hooks || otherParams.hooks?.order;
+    this.otherParams = otherParams;
     this.registerDiscountModules(options);
-    this.restoreTempOrderFromStorage();
-    const appPlugin = this.core.getPlugin('app');
-    if (!appPlugin) {
-      console.warn('Order 模块需要 app 插件支持');
-    }
-    const app = appPlugin?.getApp();
-    if (app) this.logger = app.logger;
     this.logInfo('OrderModule initialized successfully');
   }
+  async destroy() {
+    const childModules = [this.store?.discount, this.store?.rules];
+    for (const childModule of childModules) {
+      if (!childModule || typeof childModule.destroy !== 'function') continue;
+      try {
+        // Order 内部注册的子模块需要跟随父模块释放，避免 core 中残留独立模块。
+        await childModule.destroy();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logWarning('Destroy child module failed', {
+          module: childModule.name,
+          error: errorMessage
+        });
+      }
+    }
+    if (this.store) {
+      this.store.discount = null;
+      this.store.rules = null;
+    }
+    super.destroy();
+  }
+
+  /**
+   * 更新父级解决方案透传的运行态参数，并同步 Order 内部依赖的派生字段。
+   *
+   * @example
+   * orderModule.updateOtherParams({ cacheId: 'cache-2', channel: 'pos' });
+   */
+  updateOtherParams(params) {
+    const otherParams = params || {};
+    this.cacheId = otherParams.cacheId;
+    this.salesSummaryModuleName = otherParams.salesSummaryModuleName;
+    this.rulesHooksOverride = otherParams.rules?.hooks;
+    this.orderHooks = this.moduleHooksOverride || otherParams.order?.hooks || otherParams.hooks?.order;
+    this.otherParams = otherParams;
+  }
 
   /**
    * 记录信息日志
@@ -151,30 +395,70 @@ class OrderModule extends _BaseModule.BaseModule {
   // ─── Discount: 公共 API ───
 
   async loadDiscountConfig(params) {
-    const prepareConfig = await this.store.discount?.loadPrepareConfig({
+    const orderId = params.orderId || this.store.tempOrder?.order_id || undefined;
+    const prepareConfigResult = await this.store.discount?.loadPrepareConfig({
       customer_id: params.customerId,
-      action: params.action || 'create',
+      action: params.action || (orderId ? 'edit' : 'create'),
       with_good_pass: 1,
       with_discount_card: 1,
       with_wallet_pass_holder: 1,
       with_available_wallet_flag: 1,
       with_available_wallet_pass_flag: 1,
-      request_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      request_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      ...(orderId ? {
+        order_id: orderId
+      } : {})
     });
-    const discountList = prepareConfig?.discountList;
-    this.store.availableWalletIds = prepareConfig?.availableWalletIds || [];
+    const discountList = prepareConfigResult?.discountList;
+    this.store.availableWalletIds = prepareConfigResult?.availableWalletIds || [];
     if (discountList) {
-      this.store.discount?.setDiscountList(discountList);
+      const currentDiscountList = this.store.discount?.getDiscountList() || [];
+      const currentEditDiscounts = currentDiscountList.filter(discount => discount?.isEditMode);
+      const currentScanDiscounts = currentDiscountList.filter(discount => discount?.isScan);
+      const currentScanDiscountIds = new Set(currentScanDiscounts.map(discount => discount?.id));
+      const runtimeDiscountIds = new Set();
+      const runtimeDiscounts = discountList.filter(discount => {
+        if (currentScanDiscountIds.has(discount?.id)) return false;
+        if (runtimeDiscountIds.has(discount?.id)) return false;
+        runtimeDiscountIds.add(discount?.id);
+        return true;
+      });
+      const mergedDiscountList = [...currentEditDiscounts, ...currentScanDiscounts, ...runtimeDiscounts];
+      await this.store.discount?.setOriginalDiscountList(mergedDiscountList);
+      await this.store.discount?.setDiscountList(mergedDiscountList);
     }
-    if (this.store.tempOrder?.products?.length) {
+    if (params.apply !== false && this.store.tempOrder?.products?.length) {
       this.applyDiscount();
     }
+    return this.getDiscountList();
   }
   getDiscountList() {
     return this.store.discount?.getDiscountList() || [];
   }
   getAvailableWalletIds() {
-    return this.store.availableWalletIds || [];
+    return Array.isArray(this.store.availableWalletIds) ? [...this.store.availableWalletIds] : [];
+  }
+  async syncScannedDiscountsToOriginalDiscountList(discountList) {
+    const scanDiscounts = (discountList || []).filter(discount => discount?.isScan);
+    if (!scanDiscounts.length) return;
+    const scanDiscountIds = new Set(scanDiscounts.map(discount => discount?.id));
+    const originalDiscounts = this.store.discount?.getOriginalDiscountList?.() || [];
+    const nextOriginalDiscounts = [...scanDiscounts, ...originalDiscounts.filter(discount => !scanDiscountIds.has(discount?.id))];
+    await this.store.discount?.setOriginalDiscountList?.(nextOriginalDiscounts);
+  }
+  async ensureEditDiscountConfigForProductChange(tempOrder) {
+    const orderId = tempOrder.order_id;
+    const customerId = Number(tempOrder.customer_id || tempOrder.customer?.id || tempOrder._extend?.customerSnapshot?.id || tempOrder._extend?.customerSnapshot?.customer_id || 0);
+    if (!orderId || !customerId || customerId === 1) return;
+    const currentDiscountList = this.store.discount?.getDiscountList() || [];
+    const hasRuntimeDiscounts = currentDiscountList.some(discount => !discount?.isEditMode);
+    if (hasRuntimeDiscounts) return;
+    await this.loadDiscountConfig({
+      customerId,
+      action: 'edit',
+      orderId: Number(orderId),
+      apply: false
+    });
   }
   async scanCode(code, customerId) {
     const resultDiscountWithReason = (await this.store.discount?.batchSearch(code, {
@@ -193,7 +477,8 @@ class OrderModule extends _BaseModule.BaseModule {
         type: 'clientCalc',
         isAvailable: false,
         discountList: this.getDiscountList(),
-        unavailableReason: _types.UnavailableReason.Unknown
+        scannedDiscountList: resultDiscountList,
+        unavailableReason: _types2.UnavailableReason.Unknown
       };
     }
     if (!resultDiscountList.length) {
@@ -201,6 +486,7 @@ class OrderModule extends _BaseModule.BaseModule {
         type: 'server',
         isAvailable: false,
         discountList: this.getDiscountList(),
+        scannedDiscountList: resultDiscountList,
         unavailableReasonKey
       };
     }
@@ -210,16 +496,16 @@ class OrderModule extends _BaseModule.BaseModule {
     }));
     const currentSelected = this.getDiscountList().filter(n => n.isSelected);
     if (currentSelected.length && currentSelected.some(n => withScanList.some(m => m.id === n.id))) {
+      await this.syncScannedDiscountsToOriginalDiscountList(this.getDiscountList());
       return {
         type: 'clientCalc',
         isAvailable: true,
-        discountList: this.getDiscountList()
+        discountList: this.getDiscountList(),
+        scannedDiscountList: resultDiscountList
       };
     }
     const tempOrder = this.store.tempOrder;
-    const holders = tempOrder?.holder?.form_record_id ? [{
-      form_record_id: tempOrder.holder.form_record_id
-    }] : [];
+    const holders = tempOrder?.holder?.form_record || [];
     const {
       isAvailable,
       discountList: newDiscountList,
@@ -228,9 +514,9 @@ class OrderModule extends _BaseModule.BaseModule {
       productList: tempOrder?.products || [],
       oldDiscountList: this.getDiscountList(),
       newDiscountList: withScanList,
+      orderTotalAmount: Number(this.store.summary?.total_amount || 0),
       holders,
-      isFormSubject: !!tempOrder?.holder?.type && tempOrder.holder.type === 'form',
-      orderTotalAmount: Number(tempOrder?.summary?.total_amount || 0)
+      isFormSubject: !!tempOrder?.holder?.type && tempOrder.holder.type === 'form'
     }) || {
       isAvailable: false,
       discountList: this.getDiscountList()
@@ -238,111 +524,255 @@ class OrderModule extends _BaseModule.BaseModule {
     if (isAvailable && newDiscountList) {
       this.store.discount?.setDiscountList(newDiscountList);
       this.applyDiscount();
+      await this.syncScannedDiscountsToOriginalDiscountList(this.getDiscountList());
     }
     return {
       type: 'clientCalc',
       isAvailable: isAvailable || false,
       discountList: newDiscountList || this.getDiscountList(),
+      scannedDiscountList: resultDiscountList,
       unavailableReason
     };
   }
-  applyDiscount() {
+  applyDiscount(options) {
     const tempOrder = this.store.tempOrder;
     // 任意 products CRUD 后都应当重算 discount 状态；即使 products 为空，
     // 也需要让 Rules.calcDiscount 把 DiscountModule 的 isSelected / isAvailable /
-    // appliedProductDetails / savedAmount 以及 tempOrder.discount_list 复位。
+    // appliedProductDetails / savedAmount 复位。
     if (!tempOrder) return;
+    this.syncLinkedBookingHoldersToProducts(tempOrder);
+    delete tempOrder.discount_list;
+    const discountList = this.store.discount?.getDiscountList() || [];
+    const shouldSkipDiscountCalculation = this.shouldSkipDiscountCalculation(tempOrder);
+    if (shouldSkipDiscountCalculation) return;
     const rulesModule = this.store.rules;
     if (!rulesModule) return;
-    const discountList = this.store.discount?.getDiscountList() || [];
-    const holders = tempOrder.holder?.form_record_id ? [{
-      form_record_id: tempOrder.holder.form_record_id
-    }] : [];
     const result = rulesModule.calcDiscount({
       productList: tempOrder.products,
       discountList,
-      holders,
-      isFormSubject: !!tempOrder.holder?.type && tempOrder.holder.type === 'form',
-      orderTotalAmount: Number(tempOrder?.summary?.total_amount || 0)
+      holders: [],
+      isFormSubject: product => (0, _utils.resolveIsFormSubject)(tempOrder, product),
+      orderTotalAmount: Number(this.store.summary?.total_amount || 0)
+    }, {
+      reapplyBookingDiscountProductUids: options?.reapplyBookingDiscountProductUids
     });
     if (result?.productList) {
-      tempOrder.products = result.productList;
+      const previousProductsByUid = (0, _utils.indexOrderProductsByUid)(tempOrder.products);
+      tempOrder.products = this.applyProductDiscountPrices((result.productList || []).map((product, index) => {
+        const uid = (0, _utils.getOrderProductLineUid)(product);
+        const previous = (uid ? previousProductsByUid.get(uid) : undefined) ?? previousProductsByUid.get(`__index__:${index}`);
+        if (isManualProductDiscountProduct(previous)) {
+          return previous;
+        }
+        const mergedProduct = previous ? (0, _utils.mergeOrderProductDisplayFields)(previous, product) : product;
+        return {
+          ...mergedProduct,
+          discount_list: (0, _utils.normalizeOrderProductDiscountList)((0, _manualProductDiscount.syncManualProductDiscountProductNum)(mergedProduct.discount_list, mergedProduct.num))
+        };
+      }));
     }
     if (result?.discountList) {
       OrderModule.populateSavedAmounts(result.productList || tempOrder.products, result.discountList);
       this.store.discount?.setDiscountList(result.discountList);
-      tempOrder.discount_list = result.discountList.filter(d => d.isSelected);
     }
+    this.hasActiveCustomerBoundDiscount = (tempOrder.products || []).some(product => this.productHasCustomerBoundDiscount(product));
   }
 
-  // ─── TempOrder: 初始化入口 ───
+  // ─── 促销/赠品 ──────────────────────────────────────
 
-  initTempOrder(params) {
-    if (params.cacheId !== undefined) this.cacheId = params.cacheId;
-    if (params.salesSummaryModuleName !== undefined) this.salesSummaryModuleName = params.salesSummaryModuleName;
-    this.restoreTempOrderFromStorage();
+  /**
+   * 注入促销评估器。
+   *
+   * @example
+   * order.setPromotionEvaluator(appHelper.utils.promotionEvaluator);
+   */
+  setPromotionEvaluator(evaluator) {
+    this.promotionEvaluator = evaluator || null;
   }
 
-  // ─── TempOrder: localStorage 持久化 ───
+  /**
+   * 注入赠品选择 resolver。OS 需要补赠品时会 await 调用 resolver；缺省时跳过新增并 console.warn。
+   *
+   * @example
+   * order.setGiftSelectResolver(async (ctx) => {
+   *   // SDK 内部决定弹窗 or 自动选第一项，返回完整 OrderProduct[]
+   *   return giftSelectBridge.request(ctx);
+   * });
+   */
+  setGiftSelectResolver(resolver) {
+    this.giftSelectResolver = resolver || null;
+  }
 
-  getTempOrderStorageKey() {
-    if (!this.cacheId) return null;
-    return `scanOrder:tempOrder:${this.cacheId}`;
+  /**
+   * 为商品目录追加促销标签，供上层 Sales 门面复用。
+   *
+   * @example
+   * const products = order.appendPromotionTags(catalogProducts);
+   */
+  appendPromotionTags(products) {
+    return (0, _cartPromotion.appendPromotionTags)(products, this.promotionEvaluator);
   }
-  restoreTempOrderFromStorage() {
-    const key = this.getTempOrderStorageKey();
-    if (!key) return;
-    if (!this.window) return;
-    const cachedData = this.window.localStorage.getItem(key);
-    if (!cachedData) return;
+
+  /**
+   * 应用购物车促销：计算 → 差异化赠品 → 写回 tempOrder.products → emit onPromotionApplied。
+   *
+   * 调用时机：写路径（add/update/remove/clear/setCustomer）末尾自动触发；外部一般无需手动调。
+   *
+   * 关键约束：
+   * - 不调用任何公开 CRUD API（如 removeProductFromOrder），全部内部 mutate tempOrder.products，避免事件风暴；
+   * - 用 `isApplyingPromotion` 防递归；
+   * - 多选项赠品依赖 giftSelectResolver，未注入则跳过且 console.warn；
+   * - 不主动调用 applyDiscount / recalculateSummary，调用方负责跟进。
+   */
+  async applyPromotion() {
+    if (this.isApplyingPromotion) {
+      return;
+    }
+    if (!this.promotionEvaluator) {
+      return;
+    }
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder) {
+      return;
+    }
+    const strategyConfigs = this.promotionEvaluator.getStrategyConfigs?.();
+    if (Array.isArray(strategyConfigs) && strategyConfigs.length === 0) {
+      return;
+    }
+    this.isApplyingPromotion = true;
     try {
-      const parsedData = JSON.parse(cachedData);
-      if (!(0, _utils.isTempOrder)(parsedData)) {
-        this.window.localStorage.removeItem(key);
-        return;
-      }
-      if (Array.isArray(parsedData.products)) {
-        for (let i = 0; i < parsedData.products.length; i++) {
-          const p = parsedData.products[i];
-          if (!p || typeof p !== 'object') continue;
-          if (!Array.isArray(p.product_option_item)) {
-            p.product_option_item = [];
+      const result = (0, _cartPromotion.processCartPromotion)(tempOrder.products, this.promotionEvaluator);
+
+      // step 1: toRemove —— 直接过滤
+      if (result.giftActions.toRemove.length > 0) {
+        const removeSet = new Set(result.giftActions.toRemove.map(String));
+        result.products = result.products.filter(p => {
+          const uid = (0, _cartPromotion.getOrderProductUid)(p);
+          return uid ? !removeSet.has(String(uid)) : true;
+        });
+      }
+
+      // step 2: toReduce —— 调整数量
+      for (const reduce of result.giftActions.toReduce) {
+        for (const item of reduce.items) {
+          const product = result.products.find(p => (0, _cartPromotion.getOrderProductUid)(p) === item.uid);
+          if (product) {
+            product.num = item.newQuantity;
           }
-          if (!Array.isArray(p.product_bundle)) {
-            p.product_bundle = [];
+        }
+      }
+
+      // step 3: toAdd —— 补赠品
+      if (result.giftActions.toAdd.length > 0) {
+        if (!this.giftSelectResolver) {
+          if (result.giftActions.toAdd.some(g => g.giftOptions.length > 1)) {
+            // 多选项必须走 resolver；单选项也建议走（避免 OS 自造 stub），但允许跳过
+            console.warn('[OrderModule] giftSelectResolver not set, skip applying gifts', result.giftActions.toAdd);
+          } else {
+            console.warn('[OrderModule] giftSelectResolver not set, skip applying single-option gifts', result.giftActions.toAdd);
           }
-          // 不透明 identity 契约：旧缓存里可能没有 identity_key，
-          // 此处统一回填 UUID 并同步 metadata.unique_identification_number，
-          // 避免升级后 UI 侧持有的 rowKey 找不到对应行。
-          const row = p;
-          if (typeof row.identity_key !== 'string' || row.identity_key.length === 0) {
-            const newKey = (0, _utils.createUuidV4)();
-            row.identity_key = newKey;
-            if (!row.metadata || typeof row.metadata !== 'object') {
-              row.metadata = {};
+        } else {
+          for (const addAction of result.giftActions.toAdd) {
+            // 单选普通赠品可累加；预约赠品必须新增独立 booking，不能只改 num。
+            if (addAction.giftOptions.length === 1) {
+              const sameStrategy = result.products.find(p => p.metadata?._giftInfo?.strategyId === addAction.strategyId);
+              if (sameStrategy && !sameStrategy.booking_uid && !sameStrategy.metadata?.booking_uid) {
+                sameStrategy.num = (Number(sameStrategy.num) || 0) + (addAction.giftCount || 1);
+                continue;
+              }
             }
-            if (!row.metadata.unique_identification_number) {
-              row.metadata.unique_identification_number = newKey;
+            try {
+              const giftResult = await this.giftSelectResolver({
+                strategyId: addAction.strategyId,
+                strategyName: addAction.strategyName,
+                giftCount: addAction.giftCount,
+                giftOptions: addAction.giftOptions,
+                sourceProductIds: addAction.sourceProductIds
+              });
+              const giftProducts = Array.isArray(giftResult) ? giftResult : giftResult?.products;
+              const giftBookings = Array.isArray(giftResult) ? [] : giftResult?.bookings || [];
+              if (Array.isArray(giftProducts) && giftProducts.length > 0) {
+                for (const [index, gp] of giftProducts.entries()) {
+                  if (!gp) continue;
+                  const booking = giftBookings[index];
+                  if (booking) {
+                    const linked = this.createLinkedProductAndBooking({
+                      product: gp,
+                      booking
+                    });
+                    result.products.push(linked.product);
+                    tempOrder.bookings = [...(tempOrder.bookings || []), linked.booking];
+                    continue;
+                  }
+                  // normalize 略过：调用方应保证返回完整 OrderProduct。
+                  result.products.push(gp);
+                }
+              }
+            } catch (error) {
+              // 用户取消 / 选择失败 → 视为放弃本次新增
+              console.warn('[OrderModule] giftSelectResolver rejected, skip add gift', addAction.strategyId, error);
             }
           }
-          // 价格 schema 迁移：重跑 normalizeOrderProduct。
-          // `metadata.price_schema_version === 2` → 已是新语义，保留现有 main_product_* 折扣；
-          // 否则（v1 或无 metadata）→ 走 legacyDiscount 反推分支，基于新的 source + options
-          // 重算出含 option 的 main_product_*，并打上 price_schema_version: 2。
-          // 幂等：多次 restore 不会重复叠加 option/bundle。
-          parsedData.products[i] = (0, _utils3.normalizeOrderProduct)(row);
         }
       }
-      this.store.tempOrder = parsedData;
-    } catch {
-      this.window?.localStorage?.removeItem(key);
+      tempOrder.products = result.products;
+      this.lastUnfulfilledPromotions = result.unfulfilledPromotions;
+      this.lastGiftActions = result.giftActions;
+      const payload = {
+        unfulfilledPromotions: result.unfulfilledPromotions,
+        giftActions: result.giftActions,
+        gifts: result.gifts.map(g => ({
+          strategyId: g.strategyId,
+          strategyName: g.strategyName,
+          giftCount: g.giftCount,
+          giftOptions: g.giftOptions
+        })),
+        products: tempOrder.products
+      };
+      this.effectsEmit('onPromotionApplied', payload);
+    } catch (error) {
+      console.error('[OrderModule] applyPromotion failed', error);
+    } finally {
+      this.isApplyingPromotion = false;
     }
   }
+
+  /** 最近一次 applyPromotion 输出的未满足促销列表 */
+  getUnfulfilledPromotions() {
+    return this.lastUnfulfilledPromotions;
+  }
+
+  /** 最近一次 applyPromotion 输出的赠品操作 diff */
+  getLastGiftActions() {
+    return this.lastGiftActions;
+  }
+
+  // ─── TempOrder: 初始化入口 ───
+
+  initTempOrder(params) {
+    if (params.cacheId !== undefined) this.cacheId = params.cacheId;
+    if (params.salesSummaryModuleName !== undefined) this.salesSummaryModuleName = params.salesSummaryModuleName;
+  }
+
+  /**
+   * 控制 IndexedDB 草稿（saveDraft）是否写入。
+   * localStorage 版 tempOrder 持久化已废弃，此方法仅影响 saveDraft。
+   *
+   * @example
+   * order.setEnableTempOrderPersist(false); // BigSale 弹窗：跳过 ~1s 的 dbUpdate
+   */
+  setEnableTempOrderPersist(enabled) {
+    this.draftPersistEnabled = enabled;
+  }
+
+  /** 是否允许 saveDraft 写入 IndexedDB 草稿。 */
+  isTempOrderPersistEnabled() {
+    return this.draftPersistEnabled;
+  }
+
+  /** @deprecated OrderModule 不再负责 tempOrder localStorage 持久化；草稿保存请使用 IndexedDB saveDraft。 */
   persistTempOrder() {
-    const key = this.getTempOrderStorageKey();
-    if (!key || !this.store.tempOrder) return;
-    if (!this.window) return;
-    this.window.localStorage.setItem(key, JSON.stringify(this.store.tempOrder));
+    // no-op: OrderModule 的刷新恢复不再依赖 localStorage。
   }
   notifyTempOrderChanged() {
     if (!this.store.tempOrder) return;
@@ -358,263 +788,2722 @@ class OrderModule extends _BaseModule.BaseModule {
 
   createDefaultTempOrderInstance() {
     return (0, _utils.createDefaultTempOrder)({
-      now: (0, _utils.formatDateTime)(new Date()),
-      summary: (0, _utils.createEmptySummary)()
+      now: (0, _utils.formatDateTime)(new Date())
     });
   }
-  ensureTempOrder() {
-    if (this.store.tempOrder) return this.store.tempOrder;
-    const newOrder = this.createDefaultTempOrderInstance();
-    this.store.tempOrder = newOrder;
-    this.persistTempOrder();
-    return newOrder;
+  createExternalSaleNumber() {
+    const timestamp = (0, _dayjs.default)().format('YYYYMMDDHHmmssSSS');
+    const random6 = String(Math.floor(Math.random() * 1000000)).padStart(6, '0');
+    const parts = ['LOCAL'];
+    const context = this.core?.context;
+    const getData = context?.getData;
+    if (typeof getData === 'function') {
+      const shopId = getData.call(context, 'shop_id');
+      const deviceId = getData.call(context, 'device_id');
+      if (shopId !== undefined && shopId !== null && shopId !== '') {
+        parts.push(String(shopId));
+      }
+      if (deviceId !== undefined && deviceId !== null && deviceId !== '') {
+        parts.push(String(deviceId).slice(-8));
+      }
+    } else {
+      this.logWarning('external_sale_number context getData unavailable', {
+        key: 'shop_id'
+      });
+      this.logWarning('external_sale_number context getData unavailable', {
+        key: 'device_id'
+      });
+    }
+    parts.push(timestamp, random6);
+    return parts.join('_');
   }
-  restoreOrder() {
-    const freshTempOrder = this.createDefaultTempOrderInstance();
-    this.store.tempOrder = freshTempOrder;
-    this.persistTempOrder();
-    return freshTempOrder;
+  ensureExternalSaleNumber(tempOrder) {
+    if (!tempOrder.external_sale_number) {
+      tempOrder.external_sale_number = this.createExternalSaleNumber();
+    }
+    this.ensureRequestUniqueIdempotencyToken(tempOrder);
+    return tempOrder.external_sale_number;
   }
-  getTempOrder() {
-    return this.store.tempOrder;
+  ensureRequestUniqueIdempotencyToken(tempOrder) {
+    if (!tempOrder.request_unique_idempotency_token) {
+      tempOrder.request_unique_idempotency_token = `${tempOrder.external_sale_number}_${Date.now()}`;
+    }
+    return tempOrder.request_unique_idempotency_token;
   }
-  async addNewOrder() {
+  buildPaymentSyncIdempotencyToken(tempOrder, payments) {
+    const baseToken = this.ensureRequestUniqueIdempotencyToken(tempOrder);
+    const paidPaymentsCount = (payments || []).filter(payment => {
+      return String(payment?.status || '').toLowerCase() === 'paid';
+    }).length;
+    const paidCount = paidPaymentsCount > 0 ? paidPaymentsCount : payments.length;
+    return `${baseToken}_payment_${paidCount}`;
+  }
+  async saveDraft() {
+    // no-op: 普通 OrderModule 不再负责订单草稿或本地数据库持久化。
+  }
+  saveDraftInBackground() {
+    void this.saveDraft();
+  }
+  async hydrateTempOrderFromLocalRecord(record) {
+    return this.hydrateTempOrderFromRecord(record);
+  }
+  extractOrderIdFromSubmitResult(result) {
+    return result?.data?.order_id ?? result?.order_id ?? result?.data?.id ?? result?.id ?? null;
+  }
+  calculatePaymentEffectiveAmount(payment) {
+    const amount = new _decimal.default(payment.amount || 0);
+    const originAmount = new _decimal.default(payment.origin_amount ?? payment.amount ?? 0);
+    const serviceFee = new _decimal.default(payment.service_fee || 0);
+    // TODO: 后端允许 amount 表示顾客实际支付总额后，移除这个兼容分支。
+    const effectiveAmount = serviceFee.gt(0) && amount.eq(originAmount) ? amount.plus(serviceFee) : amount;
+    const rounding = new _decimal.default(payment.rounding_amount || 0);
+    return effectiveAmount.minus(rounding);
+  }
+  calculatePaymentTotal(payments) {
+    return (0, _utils.mapPaymentItemsToOrderPayments)(payments, {
+      includeVoided: false
+    }).reduce((sum, payment) => {
+      if (!isPaidPaymentRecord(payment)) return sum;
+      return sum.plus(this.calculatePaymentEffectiveAmount(payment));
+    }, new _decimal.default(0));
+  }
+  calculateOrderPaidPaymentTotal(payments) {
+    return (0, _utils.mapPaymentItemsToOrderPayments)(payments, {
+      includeVoided: false
+    }).reduce((sum, payment) => {
+      if (!isPaidPaymentRecord(payment)) return sum;
+      return sum.plus(this.calculatePaymentGapAmount(payment));
+    }, new _decimal.default(0));
+  }
+  getDepositAmount(tempOrder, summary) {
+    return new _decimal.default(summary.deposit_amount || tempOrder.deposit_amount || '0.00');
+  }
+  normalizeDepositAmount(amount) {
+    return _decimal.default.max(new _decimal.default(Number(amount) || 0), 0).toDecimalPlaces(2).toFixed(2);
+  }
+  getLastOrderDepositSnapshot() {
+    const lastOrderInfo = this.store.lastOrderInfo;
+    if (!lastOrderInfo || typeof lastOrderInfo !== 'object') return null;
+    const rawDepositAmount = lastOrderInfo.deposit_amount ?? lastOrderInfo.summary?.deposit_amount;
+    const depositAmount = this.normalizeDepositAmount(rawDepositAmount ?? 0);
+    const hasDepositAmount = new _decimal.default(depositAmount).gt(0);
+    const isDeposit = Number(lastOrderInfo.is_deposit) === 1 || hasDepositAmount;
+    if (!isDeposit || !hasDepositAmount) return null;
+    return {
+      isDeposit: 1,
+      depositAmount
+    };
+  }
+  getLastOrderSubmitSnapshot() {
+    const lastOrderInfo = this.store.lastOrderInfo;
+    if (!lastOrderInfo || typeof lastOrderInfo !== 'object') return {};
+    const businessCode = lastOrderInfo.business_code;
+    const type = lastOrderInfo.type;
+    return {
+      ...(typeof businessCode === 'string' && businessCode ? {
+        businessCode
+      } : {}),
+      ...(typeof type === 'string' && type ? {
+        type
+      } : {})
+    };
+  }
+  applyDepositAmountToSummary(tempOrder, summary, amount) {
+    const depositAmount = this.normalizeDepositAmount(amount);
+    const hasDepositAmount = new _decimal.default(depositAmount).gt(0);
+    const existedDeposit = summary.deposit && typeof summary.deposit === 'object' ? summary.deposit : undefined;
+    const nextSummary = {
+      ...summary,
+      deposit_amount: depositAmount,
+      deposit: hasDepositAmount ? {
+        ...(existedDeposit || {}),
+        total: depositAmount,
+        deposit_policy_ids: existedDeposit?.deposit_policy_ids || [],
+        hasDeposit: true
+      } : undefined
+    };
+    tempOrder.deposit_amount = depositAmount;
+    tempOrder.is_deposit = hasDepositAmount ? 1 : 0;
+    return nextSummary;
+  }
+  applyLastOrderDepositSnapshot(tempOrder, summary) {
+    const snapshot = this.getLastOrderDepositSnapshot();
+    if (!snapshot) return summary;
+    const existedDeposit = summary.deposit && typeof summary.deposit === 'object' ? summary.deposit : undefined;
+    const nextSummary = {
+      ...summary,
+      deposit_amount: snapshot.depositAmount,
+      deposit: {
+        ...(existedDeposit || {}),
+        total: snapshot.depositAmount,
+        deposit_policy_ids: existedDeposit?.deposit_policy_ids || [],
+        hasDeposit: true
+      }
+    };
+    tempOrder.deposit_amount = snapshot.depositAmount;
+    tempOrder.is_deposit = tempOrder.is_deposit === 0 && new _decimal.default(tempOrder.deposit_amount || 0).gt(0) ? 0 : snapshot.isDeposit;
+    return nextSummary;
+  }
+  isDepositOrder(tempOrder, depositAmount) {
+    return tempOrder.is_deposit === 1 && depositAmount.gt(0);
+  }
+  getOrderExpectedAmount(summary) {
+    return new _decimal.default(summary.expect_amount || summary.total_amount || 0);
+  }
+  isDepositCovered(params) {
+    const depositAmount = this.getDepositAmount(params.tempOrder, params.summary);
+    if (!this.isDepositOrder(params.tempOrder, depositAmount)) return false;
+    if (depositAmount.lte(0)) return false;
+    return params.paidAmount.gte(depositAmount);
+  }
+  getPaymentCompletion(payments) {
     const tempOrder = this.ensureTempOrder();
-    await this.recalculateSummary({
-      createIfMissing: true
+    const summary = this.store.summary || (0, _utils.createEmptySummary)();
+    const paymentList = payments || tempOrder.payments || [];
+    const refundAmount = this.getSummaryRefundAmount(summary);
+    const netPaidAmount = _decimal.default.max(this.calculateOrderPaidPaymentTotal(paymentList).minus(refundAmount), 0);
+    const depositAmount = this.getDepositAmount(tempOrder, summary);
+    const orderExpectedAmount = this.getOrderExpectedAmount(summary);
+    const isDepositFullyPaid = this.isDepositCovered({
+      tempOrder,
+      summary,
+      paidAmount: netPaidAmount
     });
-    this.persistTempOrder();
-    return tempOrder;
+    const isOrderFullyPaid = orderExpectedAmount.lte(0) ? true : netPaidAmount.gte(orderExpectedAmount);
+    const paymentStage = this.isDepositOrder(tempOrder, depositAmount) && !isDepositFullyPaid ? 'deposit' : 'normal';
+    return {
+      isFullyPaid: isOrderFullyPaid,
+      isOrderFullyPaid,
+      isDepositFullyPaid,
+      paymentStage,
+      depositAmount: depositAmount.toFixed(2),
+      orderExpectedAmount: orderExpectedAmount.toFixed(2)
+    };
   }
-  getOrderProducts() {
-    const tempOrder = this.ensureTempOrder();
-    return tempOrder.products;
+  calculateDepositPaidAmount(payments) {
+    return (payments || []).reduce((sum, payment) => {
+      const paymentRecord = payment;
+      if (!isPaidPaymentRecord(paymentRecord)) return sum;
+      const isDepositPayment = paymentRecord.type === 'deposit' || paymentRecord.order_payment_type === 'deposit';
+      if (!isDepositPayment) return sum;
+      return sum.plus(this.calculatePaymentGapAmount(paymentRecord));
+    }, new _decimal.default(0));
   }
-
-  // ─── TempOrder: 金额汇总 ───
-
-  getSalesSummary() {
-    if (!this.salesSummaryModuleName) return null;
-    return this.core.getModule(this.salesSummaryModuleName);
+  resolveNextOrderPaymentType(tempOrder) {
+    const depositAmount = new _decimal.default(tempOrder.deposit_amount || '0.00');
+    if (!this.isDepositOrder(tempOrder, depositAmount)) return 'normal';
+    if (depositAmount.lte(0)) return 'normal';
+    const depositPaidAmount = this.calculateDepositPaidAmount(tempOrder.payments || []);
+    return depositPaidAmount.lt(depositAmount) ? 'deposit' : 'normal';
   }
-  async recalculateSummary(options) {
-    const tempOrder = options?.createIfMissing ? this.ensureTempOrder() : this.store.tempOrder;
-    if (!tempOrder) return null;
-    const salesSummary = this.getSalesSummary();
-    if (!salesSummary) {
-      tempOrder.summary = (0, _utils.createEmptySummary)();
-      tempOrder.surcharge_fee = tempOrder.summary.surcharge_fee;
-      return tempOrder.summary;
+  normalizePaymentSource(payment, options) {
+    const paymentRecord = payment;
+    const metadata = paymentRecord.metadata && typeof paymentRecord.metadata === 'object' ? {
+      ...paymentRecord.metadata
+    } : {};
+    if (!metadata.unique_payment_number) {
+      metadata.unique_payment_number = (0, _utils.createUuidV4)();
     }
-    const summary = await salesSummary.getSummary({
-      products: tempOrder.products
-    });
-    tempOrder.summary = summary;
-    if (summary.is_price_include_tax !== undefined) {
-      tempOrder.is_price_include_tax = summary.is_price_include_tax;
+    const normalized = {
+      ...paymentRecord,
+      metadata,
+      origin_amount: paymentRecord.origin_amount ?? paymentRecord.amount ?? '0.00'
+    };
+    if (paymentRecord.status !== undefined) {
+      normalized.status = paymentRecord.status;
+    } else if (options?.defaultPaid !== false) {
+      normalized.status = 'paid';
     }
-    if (typeof summary.tax_title === 'string') {
-      tempOrder.tax_title = summary.tax_title;
+    return normalized;
+  }
+  updateTempOrderPaymentStatus(tempOrder, options) {
+    const summary = options?.summary || this.store.summary || (0, _utils.createEmptySummary)();
+    const paymentTotal = this.calculatePaymentTotal(tempOrder.payments || []);
+    const orderPaymentTotal = this.calculateOrderPaidPaymentTotal(tempOrder.payments || []);
+    const refundAmount = this.getSummaryRefundAmount(summary);
+    const netPaymentTotal = _decimal.default.max(orderPaymentTotal.minus(refundAmount), 0);
+    const targetAmount = this.calculatePaymentTargetAmount(tempOrder, summary, netPaymentTotal);
+    if (this.shouldKeepPaymentStatusAfterAmountRecalc(tempOrder.payment_status, {
+      netPaymentTotal,
+      paymentTotal,
+      refundAmount,
+      targetAmount,
+      previousSummary: options?.previousSummary,
+      tempOrder
+    })) {
+      return;
     }
-    tempOrder.surcharge_fee = summary.surcharge_fee;
-    tempOrder.surcharges = summary.surcharges || [];
-    tempOrder.deposit_amount = summary.deposit_amount || '0.00';
-    tempOrder.is_deposit = summary.deposit_amount !== '0.00' ? 1 : 0;
-    tempOrder.shop_discount = summary.discount_amount || '0.00';
-    return tempOrder.summary;
+    if (targetAmount.lte(0)) {
+      tempOrder.payment_status = 'paid';
+      return;
+    }
+    if (netPaymentTotal.lte(0)) {
+      tempOrder.payment_status = 'payment_processing';
+      return;
+    }
+    tempOrder.payment_status = netPaymentTotal.gte(targetAmount) ? 'paid' : 'partially_paid';
   }
-  async getScanOrderSummary() {
-    const summary = await this.recalculateSummary({
-      createIfMissing: true
+  shouldKeepPaymentStatusAfterAmountRecalc(paymentStatus, params) {
+    const normalizedStatus = String(paymentStatus || '').trim().toLowerCase();
+    if (normalizedStatus !== 'refunded' && normalizedStatus !== 'partially_refunded') {
+      return false;
+    }
+    if (normalizedStatus === 'refunded' && params.paymentTotal.gt(0) && params.refundAmount.gte(params.paymentTotal)) {
+      return true;
+    }
+    if (params.previousSummary) {
+      const previousTargetAmount = this.calculatePaymentTargetAmount(params.tempOrder, params.previousSummary, params.netPaymentTotal);
+      if (!previousTargetAmount.eq(params.targetAmount)) return false;
+    }
+    return true;
+  }
+  resolveWalletPassUseValue(payment, amount) {
+    const usageUnit = payment.wallet_pass_usage_unit && typeof payment.wallet_pass_usage_unit === 'object' ? payment.wallet_pass_usage_unit : null;
+    if (!usageUnit) return payment.wallet_pass_use_value;
+    const price = new _decimal.default(usageUnit.price || 0);
+    const points = new _decimal.default(usageUnit.points || 0);
+    if (price.lte(0) || points.lte(0)) return payment.wallet_pass_use_value;
+    return amount.div(price).times(points).toDecimalPlaces(2).toFixed(2);
+  }
+  adjustVoucherFundRecord(params) {
+    const fundRecord = params.voucher.fund_record && typeof params.voucher.fund_record === 'object' && !Array.isArray(params.voucher.fund_record) ? {
+      ...params.voucher.fund_record
+    } : null;
+    if (!fundRecord || fundRecord.using_before_value === undefined || fundRecord.using_before_value === null) {
+      return fundRecord || undefined;
+    }
+    const code = String(params.voucher.code || '').toUpperCase();
+    const isPointCard = code === 'POINTCARD' || String(params.voucher.fund_record?.tag || '').toLowerCase() === 'point_card';
+    const usingValue = isPointCard ? new _decimal.default(params.walletPassUseValue || 0) : params.amount;
+    fundRecord.using_after_value = new _decimal.default(fundRecord.using_before_value || 0).minus(usingValue).toDecimalPlaces(2).toFixed(2);
+    return fundRecord;
+  }
+  capVoucherPaymentsByRemainingAmount(params) {
+    const targetAmount = this.getPaymentTargetAmount();
+    const nonVoucherTotal = this.calculateOrderPaidPaymentTotal(params.nonVoucherPayments);
+    if (targetAmount.lte(0)) return [];
+    let remainingAmount = _decimal.default.max(targetAmount.minus(nonVoucherTotal), 0);
+    const cappedVouchers = [];
+    for (const voucher of params.vouchers) {
+      if (remainingAmount.lte(0)) break;
+      const voucherAmount = _decimal.default.max(new _decimal.default(voucher.amount || 0), 0);
+      if (voucherAmount.lte(0)) continue;
+      const cappedAmount = _decimal.default.min(voucherAmount, remainingAmount);
+      const amountText = cappedAmount.toDecimalPlaces(2).toFixed(2);
+      const walletPassUseValue = this.resolveWalletPassUseValue(voucher, cappedAmount);
+      cappedVouchers.push({
+        ...voucher,
+        amount: amountText,
+        origin_amount: amountText,
+        wallet_pass_use_value: walletPassUseValue,
+        fund_record: this.adjustVoucherFundRecord({
+          voucher: voucher,
+          amount: cappedAmount,
+          walletPassUseValue
+        })
+      });
+      remainingAmount = remainingAmount.minus(cappedAmount);
+    }
+    return cappedVouchers;
+  }
+  calculatePaidPaymentSummary(payments) {
+    return (payments || []).reduce((summary, payment) => {
+      const paymentRecord = payment;
+      if (!isPaidPaymentRecord(paymentRecord)) return summary;
+      return {
+        customerPaidAmount: summary.customerPaidAmount.plus(paymentRecord.amount || 0),
+        orderPaidAmount: summary.orderPaidAmount.plus(this.calculatePaymentOrderAmount(paymentRecord)),
+        gapPaidAmount: summary.gapPaidAmount.plus(this.calculatePaymentGapAmount(paymentRecord)),
+        payServiceChargeAmount: summary.payServiceChargeAmount.plus(this.calculatePaymentServiceFee(paymentRecord)),
+        roundingAmount: summary.roundingAmount.plus(this.calculatePaymentRoundingAmount(paymentRecord))
+      };
+    }, {
+      customerPaidAmount: new _decimal.default(0),
+      orderPaidAmount: new _decimal.default(0),
+      gapPaidAmount: new _decimal.default(0),
+      payServiceChargeAmount: new _decimal.default(0),
+      roundingAmount: new _decimal.default(0)
     });
-    if (!summary) return (0, _utils.createEmptySummary)();
-    this.persistTempOrder();
-    return summary;
   }
-
-  // ─── TempOrder: 备注 ───
-
-  updateTempOrderNote(note) {
-    const tempOrder = this.ensureTempOrder();
-    tempOrder.note = String(note || '');
-    this.persistTempOrder();
-    return tempOrder.note;
+  calculatePaymentServiceFee(payment) {
+    if (payment.service_fee !== undefined && payment.service_fee !== null && payment.service_fee !== '') {
+      return new _decimal.default(payment.service_fee || 0);
+    }
+    const serviceCharge = payment.service_charge && typeof payment.service_charge === 'object' ? payment.service_charge : {};
+    const percentage = new _decimal.default(serviceCharge.percentage || 0);
+    const fixedAmount = new _decimal.default(serviceCharge.amount || 0);
+    return new _decimal.default(payment.amount || 0).times(percentage).plus(fixedAmount);
   }
-  updateTempOrderBuzzer(buzzer) {
-    const tempOrder = this.ensureTempOrder();
-    tempOrder.buzzer = String(buzzer || '');
-    this.persistTempOrder();
-    return tempOrder.buzzer;
+  calculatePaymentGapAmount(payment) {
+    if (payment.origin_amount !== undefined && payment.origin_amount !== null && payment.origin_amount !== '') {
+      const rounding = new _decimal.default(payment.rounding_amount || 0);
+      return new _decimal.default(payment.origin_amount || 0).minus(rounding);
+    }
+    const rounding = new _decimal.default(payment.rounding_amount || 0);
+    const amount = new _decimal.default(payment.amount || 0);
+    const serviceFee = this.calculatePaymentServiceFee(payment);
+    if (serviceFee.lte(0)) return amount.minus(rounding);
+    if (!hasSyncedOrderPaymentRecord(payment)) return new _decimal.default(0);
+    return _decimal.default.max(amount.minus(serviceFee), 0).minus(rounding);
   }
-  updateTempOrderContactsInfo(contactsInfo) {
-    const tempOrder = this.ensureTempOrder();
-    tempOrder.contacts_info = Array.isArray(contactsInfo) ? contactsInfo : [];
-    this.persistTempOrder();
-    return tempOrder.contacts_info;
+  calculatePaymentOrderAmount(payment) {
+    if (payment.origin_amount !== undefined && payment.origin_amount !== null && payment.origin_amount !== '') {
+      return new _decimal.default(payment.origin_amount || 0);
+    }
+    const amount = new _decimal.default(payment.amount || 0);
+    const serviceFee = this.calculatePaymentServiceFee(payment);
+    if (serviceFee.lte(0)) return amount;
+    if (!hasSyncedOrderPaymentRecord(payment)) return new _decimal.default(0);
+    return _decimal.default.max(amount.minus(serviceFee), 0);
   }
-
-  // ─── TempOrder: 商品 CRUD ───
-
-  async addProductToOrder(product) {
-    const tempOrder = this.ensureTempOrder();
-    const hasExplicitIdentityKey = typeof product.identity_key === 'string' && product.identity_key.length > 0;
-    if (hasExplicitIdentityKey) {
-      // 调用方自持 identity_key（如 VenueBooking 外部生成）→ 走严格 identity 合并。
-      const normalizedProduct = (0, _utils3.normalizeOrderProduct)(product);
-      const productIndex = (0, _utils3.getProductIdentityIndex)(tempOrder.products, normalizedProduct);
-      if (productIndex === -1) {
-        tempOrder.products.push(normalizedProduct);
-      } else {
-        const targetProduct = tempOrder.products[productIndex];
-        tempOrder.products[productIndex] = {
-          ...targetProduct,
-          ...normalizedProduct,
-          num: (0, _utils3.getSafeProductNum)(targetProduct.num + normalizedProduct.num),
-          _origin: normalizedProduct._origin || targetProduct._origin
-        };
+  calculatePaymentRoundingAmount(payment) {
+    if (payment.rounding_amount === undefined || payment.rounding_amount === null || payment.rounding_amount === '') {
+      return new _decimal.default(0);
+    }
+    return new _decimal.default(payment.rounding_amount || 0);
+  }
+  formatSummaryMetadataMoney(value) {
+    if (value === undefined || value === null || value === '') return undefined;
+    if (value instanceof _decimal.default) return value.toFixed(2);
+    return new _decimal.default(String(value || 0)).toFixed(2);
+  }
+  syncSummaryProductMetadata(products) {
+    const moneyKeys = ['main_product_attached_bundle_surcharge_fee', 'main_product_attached_bundle_tax_fee', 'surcharge_rounding_remainder', 'tax_fee_rounding_remainder'];
+    // 整单折扣均摊层产出的 payment 维度字段，直接由计算层写入 metadata，
+    // 这里需把它们一并回写到商品 metadata 以便持久化/出站。
+    const metadataMoneyKeys = ['main_product_attached_bundle_selling_price', 'main_product_attached_bundle_payment_price'];
+    for (const product of products || []) {
+      const productRecord = product;
+      const metadata = productRecord.metadata && typeof productRecord.metadata === 'object' ? {
+        ...productRecord.metadata
+      } : {};
+      let hasMetadataPatch = false;
+      for (const key of moneyKeys) {
+        const value = this.formatSummaryMetadataMoney(productRecord[key]);
+        if (value === undefined) continue;
+        metadata[key] = value;
+        hasMetadataPatch = true;
       }
-    } else {
-      // 无 identity_key：按 SKU + 内容指纹（options + bundle）匹配既有行以累加数量；
-      // 命中时保留已有 identity_key，未命中才由 normalizeOrderProduct 自动生成 UUID。
-      const incomingFingerprint = (0, _utils3.buildProductLineFingerprint)(product.product_option_item, product.product_bundle);
-      const matchedIndex = tempOrder.products.findIndex(item => {
-        if (item.product_id !== product.product_id) return false;
-        if (item.product_variant_id !== product.product_variant_id) return false;
-        const existedFingerprint = (0, _utils3.buildProductLineFingerprint)(item.product_option_item, item.product_bundle);
-        return existedFingerprint === incomingFingerprint;
-      });
-      if (matchedIndex === -1) {
-        const normalizedProduct = (0, _utils3.normalizeOrderProduct)(product);
-        tempOrder.products.push(normalizedProduct);
-      } else {
-        const targetProduct = tempOrder.products[matchedIndex];
-        const normalizedProduct = (0, _utils3.normalizeOrderProduct)({
-          ...product,
-          identity_key: targetProduct.identity_key
-        });
-        tempOrder.products[matchedIndex] = {
-          ...targetProduct,
-          ...normalizedProduct,
-          identity_key: targetProduct.identity_key,
-          num: (0, _utils3.getSafeProductNum)(targetProduct.num + normalizedProduct.num),
-          _origin: normalizedProduct._origin || targetProduct._origin
-        };
+      for (const key of metadataMoneyKeys) {
+        const value = this.formatSummaryMetadataMoney(metadata[key]);
+        if (value === undefined) continue;
+        metadata[key] = value;
+        hasMetadataPatch = true;
+      }
+      if (metadata.average_discount_amount_rate !== undefined) {
+        hasMetadataPatch = true;
+      }
+      if (Array.isArray(productRecord.relation_surcharge_ids)) {
+        metadata.relation_surcharge_ids = productRecord.relation_surcharge_ids;
+        hasMetadataPatch = true;
+      }
+      const productPaymentPrice = this.formatSummaryMetadataMoney(productRecord.payment_price);
+      if (productPaymentPrice !== undefined) {
+        productRecord.payment_price = productPaymentPrice;
+      }
+      if (hasMetadataPatch) productRecord.metadata = metadata;
+      if (!Array.isArray(productRecord.product_bundle)) continue;
+      for (const bundle of productRecord.product_bundle) {
+        const bundleRecord = bundle;
+        const bundleMetadata = bundleRecord.metadata && typeof bundleRecord.metadata === 'object' ? {
+          ...bundleRecord.metadata
+        } : {};
+        let hasBundleMetadataPatch = false;
+        const bundleSurchargeFee = this.formatSummaryMetadataMoney(bundleRecord.surcharge_fee);
+        if (bundleSurchargeFee !== undefined) {
+          bundleMetadata.surcharge_fee = bundleSurchargeFee;
+          hasBundleMetadataPatch = true;
+        }
+        const bundlePaymentPrice = this.formatSummaryMetadataMoney(bundleRecord.bundle_payment_price);
+        if (bundlePaymentPrice !== undefined) {
+          bundleRecord.bundle_payment_price = bundlePaymentPrice;
+        }
+        if (Array.isArray(bundleRecord.relation_surcharge_ids)) {
+          bundleMetadata.relation_surcharge_ids = bundleRecord.relation_surcharge_ids;
+          hasBundleMetadataPatch = true;
+        }
+        if (hasBundleMetadataPatch) bundleRecord.metadata = bundleMetadata;
       }
     }
-    this.applyDiscount();
-    await this.recalculateSummary({
-      createIfMissing: true
-    });
-    this.persistTempOrder();
-    return tempOrder.products;
   }
-  async updateProductInOrder(params) {
+  calculateSummaryAmountGap(params) {
     const {
-      product_id,
-      product_variant_id,
-      updates,
-      identity_key,
-      product_option_item,
-      product_bundle
+      tempOrder,
+      summary,
+      orderPaidAmount
     } = params;
-    const tempOrder = this.ensureTempOrder();
+    const refundAmount = this.getSummaryRefundAmount(summary);
+    const netOrderPaidAmount = _decimal.default.max(orderPaidAmount.minus(refundAmount), 0);
+    const targetAmount = this.calculatePaymentTargetAmount(tempOrder, summary, netOrderPaidAmount);
+    return targetAmount.minus(netOrderPaidAmount).toFixed(2);
+  }
+  getSummaryRefundAmount(summary) {
+    return _decimal.default.max(new _decimal.default(summary?.total_refund_amount || 0), 0);
+  }
+  calculatePaymentTargetAmount(tempOrder, summary, paidAmount = new _decimal.default(0)) {
+    const depositAmount = this.getDepositAmount(tempOrder, summary);
+    if (!this.isDepositOrder(tempOrder, depositAmount)) {
+      return this.getOrderExpectedAmount(summary);
+    }
+    if (this.isDepositCovered({
+      tempOrder,
+      summary,
+      paidAmount
+    })) {
+      return this.getOrderExpectedAmount(summary);
+    }
+    return depositAmount;
+  }
+  normalizeFingerprintMoney(value) {
+    if (value === undefined || value === null || value === '') return '';
+    try {
+      const parsed = new _decimal.default(String(value || 0));
+      return parsed.toFixed(4);
+    } catch {
+      return String(value);
+    }
+  }
+  normalizeFingerprintValue(value) {
+    if (Array.isArray(value)) {
+      return value.map(item => this.normalizeFingerprintValue(item));
+    }
+    if (!value || typeof value !== 'object') return value ?? '';
+    return Object.keys(value).sort().reduce((result, key) => {
+      result[key] = this.normalizeFingerprintValue(value[key]);
+      return result;
+    }, {});
+  }
+  buildProductFingerprintItem(product) {
+    const sku = product?.product_sku || {};
+    const metadata = product?.metadata || {};
+    const discountTypes = (product?.discount_list || []).map(discount => discount?.type ?? discount?.tag);
+    const extensionType = product?.extension_type || (discountTypes.includes('good_pass') ? 'good_pass' : 'normal');
+    return {
+      product_id: product?.product_id ?? null,
+      product_variant_id: product?.product_variant_id ?? null,
+      extension_type: extensionType,
+      num: (0, _utils3.getSafeProductNum)(product?.num ?? product?.product_quantity),
+      selling_price: this.normalizeFingerprintMoney(product?.selling_price),
+      original_price: this.normalizeFingerprintMoney(product?.original_price),
+      payment_price: this.normalizeFingerprintMoney(product?.payment_price ?? product?.selling_price),
+      metadata: {
+        source_product_price: this.normalizeFingerprintMoney(metadata.source_product_price),
+        main_product_selling_price: this.normalizeFingerprintMoney(metadata.main_product_selling_price),
+        main_product_original_price: this.normalizeFingerprintMoney(metadata.main_product_original_price),
+        product_discount_difference: this.normalizeFingerprintMoney(metadata.product_discount_difference)
+      },
+      product_sku: this.normalizeFingerprintValue({
+        code: sku.code ?? '',
+        barcode: sku.barcode ?? '',
+        variant_id: sku.variant_id ?? product?.product_variant_id ?? 0,
+        variant: sku.variant || [],
+        option: (0, _utils.getProductSkuOptions)(product || {}).map(option => ({
+          id: option?.id ?? option?.option_group_item_id ?? null,
+          option_group_id: option?.option_group_id ?? null,
+          option_group_item_id: option?.option_group_item_id ?? option?.id ?? null,
+          num: Number(option?.num ?? 1) || 1,
+          add_price: this.normalizeFingerprintMoney(option?.add_price ?? option?.price)
+        }))
+      }),
+      product_bundle: this.normalizeFingerprintValue((product?.product_bundle || []).map(bundle => ({
+        bundle_product_id: bundle?.bundle_product_id ?? bundle?._bundle_product_id ?? bundle?.product_id ?? null,
+        bundle_variant_id: bundle?.bundle_variant_id ?? bundle?.product_variant_id ?? 0,
+        num: (0, _utils3.getSafeProductNum)(bundle?.num ?? bundle?.quantity),
+        price: this.normalizeFingerprintMoney(bundle?.price),
+        bundle_selling_price: this.normalizeFingerprintMoney(bundle?.bundle_selling_price),
+        price_type: bundle?.price_type ?? '',
+        price_type_ext: bundle?.price_type_ext ?? ''
+      }))),
+      discount_list: this.normalizeFingerprintValue((product?.discount_list || []).map(discount => ({
+        type: discount?.type ?? discount?.tag ?? '',
+        discount_id: discount?.discount_id ?? discount?.order_discount_id ?? discount?.discount?.resource_id ?? null,
+        amount: this.normalizeFingerprintMoney(discount?.amount)
+      })))
+    };
+  }
+  buildOrderProductsFingerprint(products) {
+    const items = (products || []).map(product => this.buildProductFingerprintItem(product));
+    items.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return JSON.stringify(items);
+  }
+  buildProductStructuralFingerprintItem(product) {
+    const sku = product?.product_sku || {};
+    const metadata = product?.metadata || {};
+    const discountTypes = (product?.discount_list || []).map(discount => discount?.type ?? discount?.tag);
+    const extensionType = product?.extension_type || (discountTypes.includes('good_pass') ? 'good_pass' : 'normal');
+    return {
+      product_id: product?.product_id ?? null,
+      product_variant_id: product?.product_variant_id ?? null,
+      extension_type: extensionType,
+      num: (0, _utils3.getSafeProductNum)(product?.num ?? product?.product_quantity),
+      metadata: {
+        unique_identification_number: metadata.unique_identification_number ?? product?.unique_identification_number ?? '',
+        price_override: metadata.price_override ?? '',
+        is_manual_discount: metadata.is_manual_discount ?? '',
+        product_discount_reason: metadata.product_discount_reason ?? ''
+      },
+      product_sku: this.normalizeFingerprintValue({
+        code: sku.code ?? '',
+        barcode: sku.barcode ?? '',
+        variant_id: sku.variant_id ?? product?.product_variant_id ?? 0,
+        variant: sku.variant || [],
+        option: (0, _utils.getProductSkuOptions)(product || {}).map(option => ({
+          id: option?.id ?? option?.option_group_item_id ?? null,
+          option_group_id: option?.option_group_id ?? null,
+          option_group_item_id: option?.option_group_item_id ?? option?.id ?? null,
+          num: Number(option?.num ?? 1) || 1,
+          add_price: this.normalizeFingerprintMoney(option?.add_price ?? option?.price)
+        }))
+      }),
+      product_bundle: this.normalizeFingerprintValue((product?.product_bundle || []).map(bundle => ({
+        bundle_id: bundle?.bundle_id ?? bundle?.id ?? null,
+        bundle_group_id: bundle?.bundle_group_id ?? bundle?.group_id ?? null,
+        bundle_product_id: bundle?.bundle_product_id ?? bundle?._bundle_product_id ?? bundle?.product_id ?? null,
+        bundle_variant_id: bundle?.bundle_variant_id ?? bundle?.product_variant_id ?? 0,
+        num: (0, _utils3.getSafeProductNum)(bundle?.num ?? bundle?.quantity),
+        price_type: bundle?.price_type ?? '',
+        price_type_ext: bundle?.price_type_ext ?? '',
+        option: this.normalizeFingerprintValue((bundle?.option || []).map(option => ({
+          id: option?.id ?? option?.option_group_item_id ?? null,
+          option_group_id: option?.option_group_id ?? null,
+          option_group_item_id: option?.option_group_item_id ?? option?.id ?? null,
+          num: Number(option?.num ?? 1) || 1,
+          add_price: this.normalizeFingerprintMoney(option?.add_price ?? option?.price)
+        })))
+      }))),
+      discount_list: this.normalizeFingerprintValue((product?.discount_list || []).map(discount => ({
+        type: discount?.type ?? discount?.tag ?? '',
+        discount_id: discount?.discount_id ?? discount?.order_discount_id ?? discount?.discount?.resource_id ?? null,
+        amount: this.normalizeFingerprintMoney(discount?.amount)
+      })))
+    };
+  }
+  buildOrderProductsStructuralFingerprint(products) {
+    const items = (products || []).map(product => this.buildProductStructuralFingerprintItem(product));
+    items.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return JSON.stringify(items);
+  }
+  getManualDepositOverride(tempOrder) {
+    const override = tempOrder._extend?.manualDepositOverride;
+    if (!override || typeof override !== 'object') return null;
+    if (typeof override.amount !== 'string') return null;
+    if (typeof override.productStructuralFingerprint !== 'string') return null;
+    return override;
+  }
+  setManualDepositOverride(tempOrder, amount) {
+    tempOrder._extend = {
+      ...(tempOrder._extend || {}),
+      manualDepositOverride: {
+        amount,
+        productStructuralFingerprint: this.buildOrderProductsStructuralFingerprint(tempOrder.products)
+      }
+    };
+  }
+  clearManualDepositOverride(tempOrder) {
+    if (!tempOrder._extend?.manualDepositOverride) return;
+    tempOrder._extend = {
+      ...tempOrder._extend
+    };
+    delete tempOrder._extend.manualDepositOverride;
+  }
+  getOriginalSalesSnapshot(tempOrder) {
+    const snapshot = tempOrder._extend?.originalSalesSnapshot;
+    if (!snapshot || typeof snapshot !== 'object') return null;
+    if (typeof snapshot.productFingerprint !== 'string') return null;
+    return snapshot;
+  }
+  isSnapshotPayableAmountUnchanged(tempOrder, snapshot, snapshotSummary) {
+    const currentPaidPaymentSummary = this.calculatePaidPaymentSummary(tempOrder.payments || []);
+    const currentAmountGap = this.calculateSummaryAmountGap({
+      tempOrder,
+      summary: snapshotSummary,
+      orderPaidAmount: currentPaidPaymentSummary.gapPaidAmount
+    });
+    const snapshotPaidPaymentSummary = this.calculatePaidPaymentSummary(Array.isArray(snapshot.payments) ? snapshot.payments : []);
+    const snapshotAmountGap = this.calculateSummaryAmountGap({
+      tempOrder,
+      summary: snapshotSummary,
+      orderPaidAmount: snapshotPaidPaymentSummary.gapPaidAmount
+    });
+    return currentAmountGap === snapshotAmountGap;
+  }
+  hasShopDiscountChangedFromSnapshot(tempOrder, snapshot) {
+    const snapshotSummary = snapshot.summary && typeof snapshot.summary === 'object' ? snapshot.summary : {};
+    const snapshotShopDiscount = snapshot.shop_discount ?? snapshotSummary.shop_discount;
+    if (snapshotShopDiscount === undefined || snapshotShopDiscount === null || snapshotShopDiscount === '') {
+      return !new _decimal.default(tempOrder.shop_discount || 0).equals(0);
+    }
+    return !new _decimal.default(tempOrder.shop_discount || 0).equals(snapshotShopDiscount || 0);
+  }
+  restoreOriginalSnapshotIfProductsUnchanged(tempOrder, snapshot) {
+    const currentFingerprint = this.buildOrderProductsFingerprint(tempOrder.products);
+    const manualDepositOverride = this.getManualDepositOverride(tempOrder);
+    if (currentFingerprint !== snapshot.productFingerprint) {
+      const currentStructuralFingerprint = this.buildOrderProductsStructuralFingerprint(tempOrder.products);
+      const snapshotStructuralFingerprint = this.buildOrderProductsStructuralFingerprint(Array.isArray(snapshot.products) ? snapshot.products : []);
+      if (currentStructuralFingerprint !== snapshotStructuralFingerprint) return null;
+    }
+    let summary = {
+      ...(0, _utils.createEmptySummary)(),
+      ...(0, _lodashEs.cloneDeep)(snapshot.summary || {})
+    };
+    const shouldUseManualDepositOverride = Boolean(manualDepositOverride && manualDepositOverride.productStructuralFingerprint === this.buildOrderProductsStructuralFingerprint(tempOrder.products));
+    if (shouldUseManualDepositOverride) {
+      summary = this.applyDepositAmountToSummary(tempOrder, summary, manualDepositOverride.amount);
+    } else if (manualDepositOverride) {
+      this.clearManualDepositOverride(tempOrder);
+    }
+    const isPayableAmountUnchanged = this.isSnapshotPayableAmountUnchanged(tempOrder, snapshot, summary);
+    if (!isPayableAmountUnchanged) return null;
+    if (Array.isArray(snapshot.products)) {
+      tempOrder.products = (0, _lodashEs.cloneDeep)(snapshot.products);
+    }
+    if (Array.isArray(snapshot.surcharges)) {
+      tempOrder.surcharges = (0, _lodashEs.cloneDeep)(snapshot.surcharges);
+    }
+    tempOrder.surcharge_fee = summary.surcharge_fee || tempOrder.surcharge_fee;
+    tempOrder.deposit_amount = summary.deposit_amount || '0.00';
+    tempOrder.is_deposit = summary.deposit_amount !== '0.00' ? 1 : 0;
+    const previousSummary = this.store.summary;
+    this.store.summary = summary;
+    this.updateTempOrderPaymentStatus(tempOrder, {
+      previousSummary,
+      summary
+    });
+    return summary;
+  }
+  clearPersistedAmountFieldsForFullRecalc(products) {
+    const moneyKeys = ['surcharge_fee', 'main_product_attached_bundle_surcharge_fee', 'surcharge_rounding_remainder', 'main_product_attached_bundle_tax_fee', 'tax_fee', 'original_tax_fee', 'tax_fee_rounding_remainder', 'original_tax_fee_rounding_remainder'];
+    const metadataMoneyKeys = ['main_product_attached_bundle_surcharge_fee', 'surcharge_rounding_remainder', 'main_product_attached_bundle_tax_fee', 'tax_fee_rounding_remainder'];
+    for (const product of products || []) {
+      const record = product;
+      for (const key of moneyKeys) delete record[key];
+      if (record.metadata && typeof record.metadata === 'object') {
+        record.metadata = {
+          ...record.metadata
+        };
+        for (const key of metadataMoneyKeys) delete record.metadata[key];
+      }
+      for (const bundle of record.product_bundle || []) {
+        for (const key of moneyKeys) delete bundle[key];
+        if (bundle.metadata && typeof bundle.metadata === 'object') {
+          bundle.metadata = {
+            ...bundle.metadata
+          };
+          for (const key of metadataMoneyKeys) delete bundle.metadata[key];
+        }
+      }
+    }
+  }
+  getPaymentTargetAmount() {
+    const tempOrder = this.ensureTempOrder();
+    const summary = this.store.summary || (0, _utils.createEmptySummary)();
+    const paidPaymentSummary = this.calculatePaidPaymentSummary(tempOrder.payments || []);
+    const refundAmount = this.getSummaryRefundAmount(summary);
+    const netPaidAmount = _decimal.default.max(paidPaymentSummary.gapPaidAmount.minus(refundAmount), 0);
+    return this.calculatePaymentTargetAmount(tempOrder, summary, netPaidAmount);
+  }
+  ensureTempOrder() {
+    if (this.store.tempOrder) {
+      this.ensureExternalSaleNumber(this.store.tempOrder);
+      return this.store.tempOrder;
+    }
+    const newOrder = this.createDefaultTempOrderInstance();
+    this.ensureExternalSaleNumber(newOrder);
+    this.store.tempOrder = newOrder;
+    this.persistTempOrder();
+    return newOrder;
+  }
+  restoreOrder() {
+    this.logInfo('restoreOrder start', {});
+    const freshTempOrder = this.createDefaultTempOrderInstance();
+    this.ensureExternalSaleNumber(freshTempOrder);
+    this.store.tempOrder = freshTempOrder;
+    this.store.summary = (0, _utils.createEmptySummary)();
+    this.store.lastOrderInfo = undefined;
+    this.store.syncState = undefined;
+    void this.store.discount?.setOriginalDiscountList([]);
+    void this.store.discount?.setDiscountList([]);
+    this.persistTempOrder();
+    return freshTempOrder;
+  }
+  getTempOrder() {
+    return this.store.tempOrder;
+  }
+  async replaceTempOrder(tempOrder, options) {
+    if (!(0, _utils.isTempOrder)(tempOrder)) {
+      throw new Error('无效的 tempOrder 数据');
+    }
+    const nextTempOrder = this.normalizeTempOrderForRuntime((0, _lodashEs.cloneDeep)(tempOrder), {
+      ensureIdentity: false
+    });
+    this.store.tempOrder = nextTempOrder;
+    if (options?.recalculateSummary !== false) {
+      await this.recalculateSummary({
+        createIfMissing: false
+      });
+    } else {
+      this.store.summary = (0, _utils.createEmptySummary)();
+    }
+    if (options?.persist !== false) {
+      this.persistTempOrder();
+    }
+    if (options?.saveDraft) {
+      await this.saveDraft();
+    }
+    return nextTempOrder;
+  }
+  getOrderIdentity() {
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder) return null;
+    const lastOrderInfo = this.store.lastOrderInfo || {};
+    const orderId = tempOrder.order_id ?? lastOrderInfo.order_id ?? lastOrderInfo.id ?? null;
+    return {
+      localId: this.cacheId || tempOrder._extend?.localId,
+      orderId,
+      externalSaleNumber: tempOrder.external_sale_number || lastOrderInfo.external_sale_number || '',
+      orderNumber: tempOrder.order_number || lastOrderInfo.order_number || '',
+      shopOrderNumber: tempOrder.shop_order_number || lastOrderInfo.shop_order_number || '',
+      shopFullOrderNumber: tempOrder.shop_full_order_number || lastOrderInfo.shop_full_order_number || '',
+      isSubmitted: orderId !== null && orderId !== undefined
+    };
+  }
+  getOrderSyncState() {
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder) return 'local';
+    if (this.store.syncState) return this.store.syncState;
+    if (this.store.lastOrderInfo) return 'remoteLoaded';
+    if (tempOrder.order_id) return 'submitted';
+    return 'local';
+  }
+  getOrderAmountSnapshot() {
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder) return null;
+    const summary = this.store.summary || (0, _utils.createEmptySummary)();
+    const depositAmount = tempOrder.deposit_amount || summary.deposit_amount || '0.00';
+    const paidPaymentSummary = this.calculatePaidPaymentSummary(tempOrder.payments || []);
+    const amountGap = this.calculateSummaryAmountGap({
+      tempOrder,
+      summary,
+      orderPaidAmount: paidPaymentSummary.gapPaidAmount
+    });
+    return {
+      isDeposit: tempOrder.is_deposit === 1,
+      depositAmount,
+      expectAmount: summary.expect_amount || '0.00',
+      totalAmount: summary.total_amount || '0.00',
+      amountGap,
+      summary
+    };
+  }
+  getOrderSnapshot() {
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder) return null;
+    const identity = this.getOrderIdentity();
+    const amount = this.getOrderAmountSnapshot();
+    if (!identity || !amount) return null;
+    return {
+      identity,
+      syncState: this.getOrderSyncState(),
+      amount,
+      status: tempOrder.status || '',
+      paymentStatus: tempOrder.payment_status || '',
+      shippingStatus: tempOrder.shipping_status || '',
+      note: tempOrder.note || '',
+      customer: {
+        customerId: tempOrder.customer_id ?? null,
+        customerName: tempOrder.customer_name || '',
+        phone: tempOrder.phone || '',
+        email: tempOrder.email || ''
+      },
+      productCount: tempOrder.products?.length || 0,
+      lastOrderInfo: this.store.lastOrderInfo,
+      tempOrder
+    };
+  }
+  async addNewOrder() {
+    const tempOrder = this.ensureTempOrder();
+    this.ensureExternalSaleNumber(tempOrder);
+    await this.recalculateSummary({
+      createIfMissing: true
+    });
+    this.persistTempOrder();
+    if (this.draftPersistEnabled) {
+      await this.saveDraft();
+    }
+    return tempOrder;
+  }
+  getOrderProducts() {
+    const tempOrder = this.ensureTempOrder();
+    return tempOrder.products;
+  }
+  getProductUid(product) {
+    const metadata = product.metadata && typeof product.metadata === 'object' ? product.metadata : {};
+    const uid = metadata.unique_identification_number || product.unique_identification_number || (0, _utils.createUuidV4)();
+    metadata.unique_identification_number = String(uid);
+    product.metadata = metadata;
+    return String(uid);
+  }
+  sanitizeOrderProductForTempOrder(product) {
+    if (product.metadata && typeof product.metadata === 'object') {
+      delete product.metadata.origin;
+    }
+    return product;
+  }
+  sanitizeTempOrderProducts(tempOrder) {
+    tempOrder.products = (tempOrder.products || []).map(product => this.sanitizeOrderProductForTempOrder(product));
+  }
+  ensureExtend(tempOrder) {
+    if (!tempOrder._extend || typeof tempOrder._extend !== 'object') {
+      tempOrder._extend = {
+        productsByUid: {}
+      };
+    }
+    if (!tempOrder._extend.productsByUid) {
+      tempOrder._extend.productsByUid = {};
+    }
+    return tempOrder._extend;
+  }
+  captureProductRuntime(tempOrder, rawProduct, normalizedProduct, existedUid) {
+    const uid = existedUid || this.getProductUid(normalizedProduct);
+    const extend = this.ensureExtend(tempOrder);
+    const existed = extend.productsByUid?.[uid] || {};
+    const origin = rawProduct._origin ?? normalizedProduct._origin ?? existed.origin;
+    extend.productsByUid[uid] = {
+      ...existed,
+      ...(origin !== undefined ? {
+        origin
+      } : {})
+    };
+    delete normalizedProduct._origin;
+    delete normalizedProduct.unique_identification_number;
+  }
+  createLinkedProductAndBooking(params) {
+    const productMetadata = params.product.metadata && typeof params.product.metadata === 'object' ? {
+      ...params.product.metadata
+    } : {};
+    const bookingMetadata = params.booking.metadata && typeof params.booking.metadata === 'object' ? {
+      ...params.booking.metadata
+    } : {};
+    const productUid = String(productMetadata.unique_identification_number || params.product.unique_identification_number || (0, _utils.createUuidV4)());
+    const bookingUid = String(bookingMetadata.unique_identification_number || (0, _utils.createUuidV4)());
+    productMetadata.unique_identification_number = productUid;
+    bookingMetadata.unique_identification_number = bookingUid;
+    this.syncBookingMetadataHolder(params.booking, bookingMetadata);
+    return {
+      productUid,
+      bookingUid,
+      product: {
+        ...params.product,
+        unique_identification_number: productUid,
+        metadata: {
+          ...productMetadata,
+          booking_uid: bookingUid
+        },
+        booking_uid: bookingUid
+      },
+      booking: {
+        ...params.booking,
+        is_all: (0, _utils.normalizeBookingIsAll)(params.booking),
+        product_uid: productUid,
+        sub_type: (0, _utils.normalizeBookingSubType)(params.booking),
+        metadata: bookingMetadata
+      }
+    };
+  }
+
+  /**
+   * booking.holder 是提交真源；metadata.holder 作为详情/回显冗余字段同步保存。
+   *
+   * @example
+   * this.syncBookingMetadataHolder(booking, metadata);
+   */
+  syncBookingMetadataHolder(booking, metadata) {
+    if (booking?.holder !== undefined) {
+      metadata.holder = booking.holder;
+    }
+  }
+
+  /**
+   * 从单条 booking 的 holder / metadata 中收集 holder form_record。
+   *
+   * @example
+   * const ids = this.collectBookingHolderRecords(booking);
+   */
+  collectBookingHolderRecords(booking) {
+    const holder = booking?.holder && typeof booking.holder === 'object' ? booking.holder : null;
+    const source = holder?.form_record ?? booking?.metadata?.holder_id;
+    const records = Array.isArray(source) ? source : [source];
+    return records.filter(record => record !== undefined && record !== null && record !== '');
+  }
+  setProductHolderFromBooking(product, booking) {
+    if (!product || !booking) return;
+    const holderRecords = this.collectBookingHolderRecords(booking);
+    if (!product.metadata || typeof product.metadata !== 'object') {
+      product.metadata = {};
+    }
+    product.metadata.holder_id = holderRecords.length > 0 ? holderRecords : null;
+  }
+  syncLinkedBookingHoldersToProducts(tempOrder) {
+    const bookings = tempOrder.bookings || [];
+    const products = tempOrder.products || [];
+    if (!bookings.length || !products.length) return;
+    const bookingByProductUid = new Map();
+    const bookingByBookingUid = new Map();
+    bookings.forEach(booking => {
+      if (!booking || typeof booking !== 'object') return;
+      const productUid = booking.product_uid || booking.metadata?.product_uid;
+      if (productUid !== undefined && productUid !== null && String(productUid) !== '') {
+        bookingByProductUid.set(String(productUid), booking);
+      }
+      const bookingUid = booking.metadata?.unique_identification_number || booking.booking_uid;
+      if (bookingUid !== undefined && bookingUid !== null && String(bookingUid) !== '') {
+        bookingByBookingUid.set(String(bookingUid), booking);
+      }
+    });
+    products.forEach(product => {
+      if (!product || typeof product !== 'object') return;
+      const productUid = product.metadata?.unique_identification_number || product.unique_identification_number;
+      const bookingUid = product.booking_uid || product.metadata?.booking_uid;
+      const linkedBooking = (productUid !== undefined && productUid !== null && String(productUid) !== '' ? bookingByProductUid.get(String(productUid)) : undefined) || (bookingUid !== undefined && bookingUid !== null && String(bookingUid) !== '' ? bookingByBookingUid.get(String(bookingUid)) : undefined);
+      if (linkedBooking) {
+        this.setProductHolderFromBooking(product, linkedBooking);
+      }
+    });
+  }
+
+  /**
+   * 按 form_record 顺序读取 booking holder 的主字段名称。
+   *
+   * @example
+   * const names = this.collectBookingHolderNames(booking);
+   */
+  collectBookingHolderNames(booking) {
+    const holder = booking?.holder && typeof booking.holder === 'object' ? booking.holder : null;
+    const rawName = holder?.name;
+    if (Array.isArray(rawName)) {
+      return rawName.map(name => String(name || '').trim());
+    }
+    if (typeof rawName === 'string') {
+      return rawName.split(',').map(name => name.trim());
+    }
+    return [];
+  }
+
+  /**
+   * 按老 ticketBooking `formatHolder` 语义汇总订单顶层 holder。
+   *
+   * @example
+   * const holder = this.buildTempOrderHolderFromBookings(tempOrder);
+   */
+  buildTempOrderHolderFromBookings(tempOrder) {
+    const holderRecords = [];
+    const holderNames = [];
+    let baseHolder = null;
+    const seen = new Set();
+    for (const booking of tempOrder.bookings || []) {
+      const holder = booking?.holder && typeof booking.holder === 'object' ? booking.holder : null;
+      if (!baseHolder && holder) {
+        baseHolder = holder;
+      }
+      const records = this.collectBookingHolderRecords(booking);
+      const names = this.collectBookingHolderNames(booking);
+      for (const [index, record] of records.entries()) {
+        const key = String(record);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        holderRecords.push(record);
+        if (names[index]) {
+          holderNames.push(names[index]);
+        }
+      }
+    }
+    if (!holderRecords.length) {
+      return null;
+    }
+    const nextHolder = {
+      customer_id: baseHolder?.customer_id ?? tempOrder.customer_id,
+      form_id: baseHolder?.form_id ?? tempOrder.holder?.form_id ?? 0,
+      form_record: holderRecords
+    };
+    if (holderNames.length) {
+      nextHolder.name = holderNames.join(',');
+    }
+    if (baseHolder?.is_source_shop || this.otherParams?.isFranchisee) {
+      nextHolder.is_source_shop = 1;
+    }
+    return nextHolder;
+  }
+
+  /**
+   * 将 booking 级 holder 汇总到 tempOrder 顶层 holder。
+   *
+   * @example
+   * this.syncTempOrderHolderFromBookings(tempOrder);
+   */
+  syncTempOrderHolderFromBookings(tempOrder) {
+    const bookings = tempOrder.bookings || [];
+    const hasHolderSource = bookings.some(booking => {
+      return booking?.holder !== undefined || booking?.metadata?.holder_id !== undefined;
+    });
+    const nextHolder = this.buildTempOrderHolderFromBookings(tempOrder);
+    if (nextHolder || hasHolderSource || bookings.length === 0) {
+      tempOrder.holder = nextHolder;
+    }
+    this.syncLinkedBookingHoldersToProducts(tempOrder);
+  }
+  getBookingUniqueIdentificationNumber(booking) {
+    const uid = booking?.metadata?.unique_identification_number;
+    if (uid === undefined || uid === null || uid === '') return null;
+    return String(uid);
+  }
+  findBookingIndexByUniqueIdentificationNumber(tempOrder, uniqueIdentificationNumber) {
+    return (tempOrder.bookings || []).findIndex(booking => {
+      return this.getBookingUniqueIdentificationNumber(booking) === uniqueIdentificationNumber;
+    });
+  }
+  removeLinkedBookingsForProduct(tempOrder, product) {
+    const productUid = product?.metadata?.unique_identification_number || product?.unique_identification_number;
+    const bookingUid = product?.booking_uid || product?.metadata?.booking_uid;
+    if (!productUid && !bookingUid) return;
+    tempOrder.bookings = (tempOrder.bookings || []).filter(booking => {
+      const currentBookingUid = this.getBookingUniqueIdentificationNumber(booking);
+      if (bookingUid && currentBookingUid === String(bookingUid)) return false;
+      if (productUid && String(booking?.product_uid || '') === String(productUid)) return false;
+      return true;
+    });
+  }
+
+  // ─── TempOrder: 金额汇总 ───
+
+  getSalesSummary() {
+    if (!this.salesSummaryModuleName) return null;
+    return this.core.getModule(this.salesSummaryModuleName);
+  }
+  applyOrderProductsDepositSummary(tempOrder, summary) {
+    const depositSummary = (0, _utils.calculateOrderProductsDeposit)(tempOrder.products || [], {
+      productsByUid: tempOrder._extend?.productsByUid
+    });
+    const manualDepositOverride = this.getManualDepositOverride(tempOrder);
+    const currentStructuralFingerprint = manualDepositOverride ? this.buildOrderProductsStructuralFingerprint(tempOrder.products) : '';
+    const shouldUseManualDepositOverride = Boolean(manualDepositOverride && manualDepositOverride.productStructuralFingerprint === currentStructuralFingerprint);
+    if (manualDepositOverride && !shouldUseManualDepositOverride) {
+      this.clearManualDepositOverride(tempOrder);
+    }
+    const depositAmount = shouldUseManualDepositOverride ? manualDepositOverride.amount : depositSummary.totalText;
+    const hasDepositAmount = new _decimal.default(depositAmount).gt(0);
+    const nextSummary = {
+      ...summary,
+      deposit_amount: depositAmount,
+      deposit: hasDepositAmount ? {
+        total: depositAmount,
+        deposit_policy_ids: depositSummary.deposit_policy_ids,
+        deposit_policy_data: depositSummary.protocols,
+        hasDeposit: true
+      } : undefined
+    };
+    const isExistingDepositDisabled = tempOrder.is_deposit === 0 && new _decimal.default(tempOrder.deposit_amount || 0).gt(0);
+    tempOrder.deposit_amount = depositAmount;
+    tempOrder.is_deposit = hasDepositAmount && !isExistingDepositDisabled ? 1 : 0;
+    return this.applyLastOrderDepositSnapshot(tempOrder, nextSummary);
+  }
+  async recalculateSummary(options) {
+    const tempOrder = options?.createIfMissing ? this.ensureTempOrder() : this.store.tempOrder;
+    if (!tempOrder) return null;
+    this.sanitizeTempOrderProducts(tempOrder);
+    const originalSnapshot = this.getOriginalSalesSnapshot(tempOrder);
+    const hasShopDiscountChanged = originalSnapshot ? this.hasShopDiscountChangedFromSnapshot(tempOrder, originalSnapshot) : false;
+    const shouldReuseOriginalSnapshot = originalSnapshot && !hasShopDiscountChanged;
+    const snapshotSummary = shouldReuseOriginalSnapshot ? this.restoreOriginalSnapshotIfProductsUnchanged(tempOrder, originalSnapshot) : null;
+    if (snapshotSummary) return snapshotSummary;
+    const shouldFullRecalculateFromSnapshot = Boolean(originalSnapshot);
+    const summaryProducts = shouldFullRecalculateFromSnapshot ? (0, _lodashEs.cloneDeep)(tempOrder.products || []) : tempOrder.products;
+    if (shouldFullRecalculateFromSnapshot) {
+      this.clearPersistedAmountFieldsForFullRecalc(summaryProducts || []);
+    }
+    const salesSummary = this.getSalesSummary();
+    const existedSummary = this.store.summary || (0, _utils.createEmptySummary)();
+    const totalRefundAmount = existedSummary.total_refund_amount || '0.00';
+    const paidPaymentSummary = this.calculatePaidPaymentSummary(tempOrder.payments || []);
+    if (!salesSummary) {
+      const emptyBaseSummary = {
+        ...(0, _utils.createEmptySummary)(),
+        ...existedSummary,
+        total_refund_amount: totalRefundAmount
+      };
+      const emptySummaryBase = {
+        ...emptyBaseSummary,
+        customer_paid_amount: paidPaymentSummary.customerPaidAmount.toFixed(2),
+        order_paid_amount: paidPaymentSummary.orderPaidAmount.toFixed(2),
+        pay_service_charge_amount: paidPaymentSummary.payServiceChargeAmount.toFixed(2),
+        rounding_amount: paidPaymentSummary.roundingAmount.toFixed(2)
+      };
+      const emptySummaryWithDeposit = this.applyOrderProductsDepositSummary(tempOrder, emptySummaryBase);
+      const emptySummary = {
+        ...emptySummaryWithDeposit,
+        amount_gap: this.calculateSummaryAmountGap({
+          tempOrder,
+          summary: emptySummaryWithDeposit,
+          orderPaidAmount: paidPaymentSummary.gapPaidAmount
+        })
+      };
+      tempOrder.surcharge_fee = emptySummary.surcharge_fee;
+      this.store.summary = emptySummary;
+      this.updateTempOrderPaymentStatus(tempOrder, {
+        previousSummary: existedSummary,
+        summary: emptySummary
+      });
+      return this.store.summary;
+    }
+    const salesSummaryResult = await salesSummary.getSummary({
+      products: summaryProducts,
+      isPriceIncludeTax: tempOrder.is_price_include_tax,
+      shopDiscount: tempOrder.shop_discount,
+      ...(this.otherParams?.channel ? {
+        channel: this.otherParams.channel
+      } : {})
+    });
+    if (shouldFullRecalculateFromSnapshot) {
+      tempOrder.products = summaryProducts;
+    }
+    this.syncSummaryProductMetadata(tempOrder.products || []);
+    const roundingAmount = paidPaymentSummary.roundingAmount;
+    const payServiceChargeAmount = paidPaymentSummary.payServiceChargeAmount;
+    const hasSalesSummaryAmount = salesSummaryResult.expect_amount !== undefined || salesSummaryResult.total_amount !== undefined;
+    const expectAmount = hasSalesSummaryAmount ? new _decimal.default(salesSummaryResult.expect_amount ?? salesSummaryResult.total_amount ?? 0) : null;
+    const amountPaymentPatch = hasSalesSummaryAmount || !roundingAmount.eq(0) || !payServiceChargeAmount.eq(0) ? {
+      rounding_amount: roundingAmount.toFixed(2),
+      ...(expectAmount ? {
+        total_amount: _decimal.default.max(0, expectAmount.plus(roundingAmount).plus(payServiceChargeAmount)).toFixed(2)
+      } : {})
+    } : {};
+    const normalizedExpectAmountPatch = expectAmount && salesSummaryResult.expect_amount === undefined ? {
+      expect_amount: expectAmount.toFixed(2)
+    } : {};
+    const summaryForGap = this.applyOrderProductsDepositSummary(tempOrder, {
+      ...salesSummaryResult,
+      total_refund_amount: totalRefundAmount,
+      ...amountPaymentPatch,
+      ...normalizedExpectAmountPatch
+    });
+    const summary = {
+      ...summaryForGap,
+      total_refund_amount: totalRefundAmount,
+      customer_paid_amount: paidPaymentSummary.customerPaidAmount.toFixed(2),
+      order_paid_amount: paidPaymentSummary.orderPaidAmount.toFixed(2),
+      ...amountPaymentPatch,
+      ...normalizedExpectAmountPatch,
+      amount_gap: this.calculateSummaryAmountGap({
+        tempOrder,
+        summary: summaryForGap,
+        orderPaidAmount: paidPaymentSummary.gapPaidAmount
+      }),
+      pay_service_charge_amount: payServiceChargeAmount.toFixed(2)
+    };
+    this.store.summary = summary;
+    if (summary.is_price_include_tax !== undefined) {
+      tempOrder.is_price_include_tax = summary.is_price_include_tax;
+    }
+    if (typeof summary.tax_title === 'string' && summary.tax_title) {
+      tempOrder.tax_title = summary.tax_title;
+    }
+    tempOrder.surcharge_fee = summary.surcharge_fee;
+    tempOrder.surcharges = summary.surcharges || [];
+    this.updateTempOrderPaymentStatus(tempOrder, {
+      previousSummary: existedSummary,
+      summary
+    });
+    return this.store.summary;
+  }
+  async getOrderSummary() {
+    const summary = await this.recalculateSummary({
+      createIfMissing: true
+    });
+    if (!summary) return (0, _utils.createEmptySummary)();
+    this.persistTempOrder();
+    return summary;
+  }
+
+  // ─── TempOrder: 备注 ───
+
+  updateTempOrderNote(note, sync = false) {
+    const tempOrder = this.ensureTempOrder();
+    tempOrder.note = String(note || '');
+    this.persistTempOrder();
+    if (sync) {
+      const orderId = tempOrder.order_id;
+      if (!orderId) return tempOrder.note;
+      return this.syncTempOrderNoteToRemote(orderId, tempOrder.note);
+    }
+    return tempOrder.note;
+  }
+  async syncTempOrderNoteToRemote(orderId, note) {
+    await this.request.put(`/order/order/${orderId}/note`, {
+      note
+    });
+    return note;
+  }
+  getTempOrderNote() {
+    return this.store.tempOrder?.note || '';
+  }
+  updateTempOrderShopDiscount(amount) {
+    const tempOrder = this.ensureTempOrder();
+    const discount = _decimal.default.max(new _decimal.default(Number(amount) || 0), 0).toDecimalPlaces(2).toFixed(2);
+    tempOrder.shop_discount = discount;
+    this.persistTempOrder();
+    return tempOrder.shop_discount;
+  }
+  updateTempOrderDepositAmount(amount) {
+    const tempOrder = this.ensureTempOrder();
+    const depositAmount = this.normalizeDepositAmount(amount);
+    const previousSummary = this.store.summary || (0, _utils.createEmptySummary)();
+    const summaryWithDeposit = this.applyDepositAmountToSummary(tempOrder, {
+      ...(0, _utils.createEmptySummary)(),
+      ...previousSummary
+    }, depositAmount);
+    this.setManualDepositOverride(tempOrder, depositAmount);
+    const paidPaymentSummary = this.calculatePaidPaymentSummary(tempOrder.payments || []);
+    const summary = {
+      ...summaryWithDeposit,
+      amount_gap: this.calculateSummaryAmountGap({
+        tempOrder,
+        summary: summaryWithDeposit,
+        orderPaidAmount: paidPaymentSummary.gapPaidAmount
+      })
+    };
+    this.store.summary = summary;
+    this.updateTempOrderPaymentStatus(tempOrder, {
+      previousSummary,
+      summary
+    });
+    this.persistTempOrder();
+    return summary;
+  }
+  updateTempOrderBuzzer(buzzer) {
+    const tempOrder = this.ensureTempOrder();
+    tempOrder.buzzer = String(buzzer || '');
+    this.persistTempOrder();
+    return tempOrder.buzzer;
+  }
+  updateTempOrderContactsInfo(contactsInfo) {
+    const tempOrder = this.ensureTempOrder();
+    tempOrder.contacts_info = contactsInfo && typeof contactsInfo === 'object' && !Array.isArray(contactsInfo) ? contactsInfo : null;
+    this.persistTempOrder();
+    return tempOrder.contacts_info;
+  }
+  buildTempOrderCustomer(params) {
+    if (!params.customerId) return null;
+    const source = params.source ? (0, _lodashEs.cloneDeep)(params.source) : {};
+    const name = source.name ?? source.display_name ?? source.customerName ?? source.customer_name ?? params.customerName;
+    const customerName = source.customer_name ?? source.customerName ?? source.display_name ?? source.name ?? params.customerName;
+    return {
+      ...source,
+      id: source.id ?? params.customerId,
+      customer_id: source.customer_id ?? params.customerId,
+      name: String(name || ''),
+      customer_name: String(customerName || ''),
+      country_calling_code: String(source.country_calling_code ?? source.countryCallingCode ?? params.countryCallingCode),
+      phone: String(source.phone ?? params.phone),
+      email: String(source.email ?? params.email)
+    };
+  }
+  isCustomerBoundDiscount(discount) {
+    const type = discount?.type ?? discount?.tag;
+    return type === 'good_pass' || type === 'discount_card' || type === 'product_discount_card';
+  }
+  shouldKeepCustomerBoundDiscountAfterCustomerChange(discount) {
+    return Boolean(discount?.isScan || discount?.isEditMode);
+  }
+  productHasCustomerBoundDiscount(product) {
+    if ((product?.discount_list || []).some(discount => this.isCustomerBoundDiscount(discount))) {
+      return true;
+    }
+    return (product?.product_bundle || []).some(bundle => (bundle?.discount_list || []).some(discount => this.isCustomerBoundDiscount(discount)));
+  }
+  shouldSkipDiscountCalculation(tempOrder) {
+    if (this.hasActiveCustomerBoundDiscount) return false;
+    const discountList = this.store.discount?.getDiscountList?.() || [];
+    if (discountList.length > 0) return false;
+    return !(tempOrder.products || []).some(product => this.productHasCustomerBoundDiscount(product));
+  }
+  clearCustomerBoundDiscounts(tempOrder) {
+    let didRemoveCustomerBoundDiscount = false;
+    const filterDiscountList = discountList => {
+      if (!Array.isArray(discountList)) return [];
+      return discountList.filter(discount => {
+        const shouldRemove = this.isCustomerBoundDiscount(discount);
+        if (shouldRemove) didRemoveCustomerBoundDiscount = true;
+        return !shouldRemove;
+      });
+    };
+    tempOrder.products = (tempOrder.products || []).map(product => {
+      const nextProduct = {
+        ...product,
+        discount_list: filterDiscountList(product.discount_list)
+      };
+      if (Array.isArray(nextProduct.product_bundle)) {
+        nextProduct.product_bundle = nextProduct.product_bundle.map(bundle => ({
+          ...bundle,
+          discount_list: filterDiscountList(bundle.discount_list)
+        }));
+      }
+      return nextProduct;
+    });
+    delete tempOrder.discount_list;
+    if (didRemoveCustomerBoundDiscount) {
+      this.hasActiveCustomerBoundDiscount = true;
+    }
+    const discountModule = this.store.discount;
+    if (!discountModule) return;
+    const currentDiscounts = discountModule.getDiscountList?.() || [];
+    const currentOriginalDiscounts = discountModule.getOriginalDiscountList?.() || [];
+    const nextDiscounts = currentDiscounts.filter(discount => {
+      if (this.shouldKeepCustomerBoundDiscountAfterCustomerChange(discount)) return true;
+      return !this.isCustomerBoundDiscount(discount);
+    });
+    const nextOriginalDiscounts = currentOriginalDiscounts.filter(discount => {
+      if (this.shouldKeepCustomerBoundDiscountAfterCustomerChange(discount)) return true;
+      return !this.isCustomerBoundDiscount(discount);
+    });
+    void discountModule.setDiscountList?.(nextDiscounts);
+    void discountModule.setOriginalDiscountList?.(nextOriginalDiscounts);
+  }
+
+  /**
+   * 更新当前 tempOrder 的客户协议字段。
+   *
+   * PaymentModal 只需要修改订单里的客户事实；如果外部还有客户模块需要同步，
+   * 应由调用方通过回调处理，不能把外部 UI 状态写进 tempOrder。
+   */
+  updateTempOrderCustomer(customer) {
+    const tempOrder = this.ensureTempOrder();
+    const previousCustomerId = tempOrder.customer_id ?? null;
+    const customerId = customer.customer_id ?? customer.customerId ?? customer.id ?? null;
+    const customerName = customer.customer_name ?? customer.customerName ?? customer.display_name ?? customer.name ?? '';
+    tempOrder.customer_id = customerId === null || customerId === undefined || customerId === '' ? null : Number(customerId);
+    tempOrder.customer_name = String(customerName || '');
+    tempOrder.country_calling_code = String(customer.country_calling_code ?? customer.countryCallingCode ?? '');
+    tempOrder.phone = String(customer.phone || '');
+    tempOrder.email = String(customer.email || '');
+    tempOrder.customer = this.buildTempOrderCustomer({
+      source: customer,
+      customerId: tempOrder.customer_id,
+      customerName: tempOrder.customer_name,
+      countryCallingCode: tempOrder.country_calling_code,
+      phone: tempOrder.phone,
+      email: tempOrder.email
+    });
+    const nextCustomerId = tempOrder.customer_id ?? null;
+    this.persistTempOrder();
+    return {
+      customerId: tempOrder.customer_id,
+      customerName: tempOrder.customer_name,
+      phone: tempOrder.phone,
+      email: tempOrder.email
+    };
+  }
+  setOrderCustomer(patch, snapshot) {
+    if (!patch) {
+      this.clearOrderCustomer();
+      return;
+    }
+    const tempOrder = this.ensureTempOrder();
+    const previousCustomerId = tempOrder.customer_id ?? null;
+    tempOrder.customer_id = patch.customer_id || patch.id || null;
+    tempOrder.customer_name = String(patch.customer_name || '');
+    tempOrder.country_calling_code = String(patch.country_calling_code || '');
+    tempOrder.phone = String(patch.phone || '');
+    tempOrder.email = String(patch.email || '');
+    tempOrder.customer = this.buildTempOrderCustomer({
+      source: snapshot || null,
+      customerId: tempOrder.customer_id,
+      customerName: tempOrder.customer_name,
+      countryCallingCode: tempOrder.country_calling_code,
+      phone: tempOrder.phone,
+      email: tempOrder.email
+    });
+    if (snapshot !== undefined) {
+      const extend = this.ensureExtend(tempOrder);
+      if (snapshot === null) delete extend.customerSnapshot;else extend.customerSnapshot = (0, _lodashEs.cloneDeep)(snapshot);
+    }
+    const nextCustomerId = tempOrder.customer_id ?? null;
+    if (String(previousCustomerId ?? '') !== String(nextCustomerId ?? '')) {
+      this.store.availableWalletIds = [];
+      (0, _utils.clearTempOrderHolderAssignments)(tempOrder);
+      this.clearCustomerBoundDiscounts(tempOrder);
+      this.applyDiscount();
+    }
+    this.persistTempOrder();
+    this.saveDraftInBackground();
+    if (String(previousCustomerId ?? '') !== String(nextCustomerId ?? '')) {
+      this.emitOrderCustomerChange();
+    }
+  }
+  getOrderCustomer() {
+    const tempOrder = this.store.tempOrder;
+    if (!tempOrder || !tempOrder.customer_id) {
+      return null;
+    }
+    return {
+      customer_id: tempOrder.customer_id,
+      customer_name: tempOrder.customer_name || '',
+      country_calling_code: tempOrder.country_calling_code || '',
+      phone: tempOrder.phone || '',
+      email: tempOrder.email || ''
+    };
+  }
+  getOrderCustomerSnapshot() {
+    const snapshot = this.store.tempOrder?._extend?.customerSnapshot;
+    return snapshot ? (0, _lodashEs.cloneDeep)(snapshot) : null;
+  }
+  clearOrderCustomer() {
+    const tempOrder = this.ensureTempOrder();
+    (0, _utils.clearTempOrderHolderAssignments)(tempOrder);
+    tempOrder.customer_id = null;
+    tempOrder.customer_name = '';
+    tempOrder.country_calling_code = '';
+    tempOrder.phone = '';
+    tempOrder.email = '';
+    tempOrder.customer = null;
+    if (tempOrder._extend) delete tempOrder._extend.customerSnapshot;
+    this.store.availableWalletIds = [];
+    this.clearCustomerBoundDiscounts(tempOrder);
+    this.persistTempOrder();
+    this.saveDraftInBackground();
+    this.core.effects.emit(_types.OrderHooks.OnOrderCustomerChange, null);
+  }
+  emitOrderCustomerChange() {
+    const patch = this.getOrderCustomer();
+    if (!patch) {
+      this.core.effects.emit(_types.OrderHooks.OnOrderCustomerChange, null);
+      return;
+    }
+    const payload = {
+      patch,
+      snapshot: this.getOrderCustomerSnapshot()
+    };
+    this.core.effects.emit(_types.OrderHooks.OnOrderCustomerChange, payload);
+  }
+
+  /**
+   * 读取当前订单的 Sales 协议支付项。
+   *
+   * 这里返回的是 tempOrder.payments，而不是旧 PaymentModule 的本地
+   * payment order / tender session。Sales checkout 以该数组为提交事实来源。
+   */
+  getOrderPayments() {
+    const tempOrder = this.ensureTempOrder();
+    return tempOrder.payments || [];
+  }
+
+  /**
+   * 用一组支付来源覆盖当前订单支付项。
+   *
+   * 入参允许来自 PaymentModule 的 PaymentItem，内部统一映射为 Sales 协议：
+   * uuid -> metadata.unique_payment_number，id -> custom_payment_id，
+   * isSynced 等运行态字段不会进入 tempOrder.payments。
+   */
+  setOrderPayments(payments) {
+    const tempOrder = this.ensureTempOrder();
+    tempOrder.payments = (0, _utils.mapPaymentItemsToOrderPayments)(payments);
+    this.persistTempOrder();
+    return tempOrder.payments;
+  }
+
+  /** 追加单个支付项，并立即持久化当前 tempOrder。 */
+  addOrderPayment(payment) {
+    this.logInfo('addOrderPayment', {
+      payment
+    });
+    const tempOrder = this.ensureTempOrder();
+    const orderPaymentType = this.resolveNextOrderPaymentType(tempOrder);
+    const mapped = (0, _utils.mapPaymentItemsToOrderPayments)([this.normalizePaymentSource({
+      ...payment,
+      type: orderPaymentType,
+      order_payment_type: orderPaymentType
+    }, {
+      defaultPaid: true
+    })]);
+    tempOrder.payments = [...(tempOrder.payments || []), ...mapped];
+    this.persistTempOrder();
+    void this.recalculateSummary({
+      createIfMissing: true
+    }).catch(error => {
+      this.logError('recalculate summary after addOrderPayment failed', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    return tempOrder.payments;
+  }
+
+  /**
+   * 按支付唯一号、后端支付 ID、自定义支付方式 ID 或旧 uuid 更新支付项。
+   *
+   * 该方法服务 PaymentModal 的 void / 编辑场景；更新 metadata 时会做浅合并，
+   * 避免覆盖 unique_payment_number、现金实付/找零等已有元数据。
+   */
+  updateOrderPayment(paymentIdentity, updates) {
+    const tempOrder = this.ensureTempOrder();
+    const identity = String(paymentIdentity);
+    tempOrder.payments = (tempOrder.payments || []).map(payment => {
+      const uniquePaymentNumber = payment?.metadata?.unique_payment_number;
+      const orderPaymentId = payment?.order_payment_id;
+      const customPaymentId = payment?.custom_payment_id;
+      const uuid = payment?.uuid;
+      const matched = [uniquePaymentNumber, orderPaymentId, customPaymentId, uuid].some(value => value !== undefined && String(value) === identity);
+      if (!matched) return payment;
+      return {
+        ...payment,
+        ...updates,
+        metadata: {
+          ...(payment.metadata || {}),
+          ...(updates.metadata || {})
+        }
+      };
+    });
+    this.persistTempOrder();
+    return tempOrder.payments;
+  }
+
+  /** 从当前订单支付项中移除指定支付项。 */
+  deleteOrderPayment(paymentIdentity) {
+    const tempOrder = this.ensureTempOrder();
+    const identity = String(paymentIdentity);
+    tempOrder.payments = (tempOrder.payments || []).filter(payment => {
+      const uniquePaymentNumber = payment?.metadata?.unique_payment_number;
+      const orderPaymentId = payment?.order_payment_id;
+      const customPaymentId = payment?.custom_payment_id;
+      const uuid = payment?.uuid;
+      return ![uniquePaymentNumber, orderPaymentId, customPaymentId, uuid].some(value => value !== undefined && String(value) === identity);
+    });
+    this.persistTempOrder();
+    return tempOrder.payments;
+  }
+  confirmPendingVoucherPaymentsInList(payments) {
+    return (payments || []).map(payment => {
+      if (!isPendingVoucherPaymentRecord(payment)) return payment;
+      return {
+        ...payment,
+        status: ORDER_PAYMENT_STATUS_PAID
+      };
+    });
+  }
+  discardPendingVoucherPaymentsFromList(payments) {
+    return (payments || []).filter(payment => !isPendingVoucherPaymentRecord(payment));
+  }
+  prepareVoucherPaymentsForSubmit(payments, confirmPendingVoucherPayments = true) {
+    const mappedPayments = (0, _utils.mapPaymentItemsToOrderPayments)(payments || []);
+    return confirmPendingVoucherPayments ? this.confirmPendingVoucherPaymentsInList(mappedPayments) : this.discardPendingVoucherPaymentsFromList(mappedPayments);
+  }
+  applyPaymentLifecycleChange(tempOrder, options) {
+    this.updateTempOrderPaymentStatus(tempOrder);
+    if (options?.persist !== false) {
+      this.persistTempOrder();
+    }
+    if (options?.recalculateSummary === false) return;
+    const logContext = options?.logContext || 'payment lifecycle change';
+    void this.recalculateSummary({
+      createIfMissing: true
+    }).catch(error => {
+      this.logError(`recalculate summary after ${logContext} failed`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  confirmPendingVoucherPayments(options) {
+    const tempOrder = this.ensureTempOrder();
+    const payments = tempOrder.payments || [];
+    const hasPendingVoucher = payments.some(payment => isPendingVoucherPaymentRecord(payment));
+    if (!hasPendingVoucher) return payments;
+    tempOrder.payments = this.confirmPendingVoucherPaymentsInList(payments);
+    this.applyPaymentLifecycleChange(tempOrder, {
+      ...options,
+      logContext: 'confirmPendingVoucherPayments'
+    });
+    // this.recalculateSummary();
+    return tempOrder.payments;
+  }
+  discardPendingVoucherPayments(options) {
+    const tempOrder = this.ensureTempOrder();
+    const payments = tempOrder.payments || [];
+    const nextPayments = this.discardPendingVoucherPaymentsFromList(payments);
+    if (nextPayments.length === payments.length) return payments;
+    tempOrder.payments = nextPayments;
+    this.applyPaymentLifecycleChange(tempOrder, {
+      ...options,
+      logContext: 'discardPendingVoucherPayments'
+    });
+    return tempOrder.payments;
+  }
+
+  /**
+   * 覆盖当前订单中的 wallet pass 支付项。
+   *
+   * 判断口径与 PaymentModal 保持一致：voucher_id 存在且不为 0 的支付项
+   * 视为 wallet pass；其它支付项保持不变。
+   */
+  updateVoucherOrderPayments(payments, options) {
+    const tempOrder = this.ensureTempOrder();
+    const isOrderPaymentType = value => {
+      return value === 'normal' || value === 'deposit';
+    };
+    const voucherOrderPaymentType = this.resolveNextOrderPaymentType(tempOrder);
+    const withVoucherPaymentType = payment => {
+      const paymentRecord = payment;
+      if (!isVoucherPaymentRecord(paymentRecord)) return payment;
+      const explicitPaymentType = isOrderPaymentType(paymentRecord.order_payment_type) ? paymentRecord.order_payment_type : isOrderPaymentType(paymentRecord.type) ? paymentRecord.type : undefined;
+      const nextPaymentType = explicitPaymentType || voucherOrderPaymentType;
+      const shouldPreserveCustomPaymentType = paymentRecord.custom_payment_type === undefined && paymentRecord.type !== undefined && !isOrderPaymentType(paymentRecord.type);
+      return {
+        ...paymentRecord,
+        ...(shouldPreserveCustomPaymentType ? {
+          custom_payment_type: paymentRecord.type
+        } : {}),
+        type: nextPaymentType,
+        order_payment_type: nextPaymentType
+      };
+    };
+    const normalizeVoucherPaymentStatus = payment => {
+      const paymentRecord = payment;
+      if (!isVoucherPaymentRecord(paymentRecord)) return payment;
+      if (hasSyncedOrderPaymentRecord(paymentRecord) && (paymentRecord.status === undefined || paymentRecord.status === 'active')) {
+        return {
+          ...paymentRecord,
+          status: ORDER_PAYMENT_STATUS_PAID
+        };
+      }
+      if (paymentRecord.status !== undefined && paymentRecord.status !== 'active') {
+        return payment;
+      }
+      return {
+        ...paymentRecord,
+        status: options?.status || ORDER_PAYMENT_STATUS_PENDING
+      };
+    };
+    const mappedVouchers = (0, _utils.mapPaymentItemsToOrderPayments)(payments.map(payment => this.normalizePaymentSource(normalizeVoucherPaymentStatus(withVoucherPaymentType(payment)), {
+      defaultPaid: false
+    }))).filter(payment => {
+      return isVoucherPaymentRecord(payment);
+    });
+    const nonVoucherPayments = (tempOrder.payments || []).filter(payment => {
+      return !isVoucherPaymentRecord(payment);
+    });
+    const normalizeCommittedVoucherPayment = payment => {
+      if (hasSyncedOrderPaymentRecord(payment) && (payment.status === undefined || payment.status === 'active')) {
+        return {
+          ...payment,
+          status: ORDER_PAYMENT_STATUS_PAID
+        };
+      }
+      return payment;
+    };
+    const committedVoucherPayments = (tempOrder.payments || []).filter(payment => isCommittedVoucherPaymentRecord(payment)).map(payment => normalizeCommittedVoucherPayment(payment));
+    const committedVoucherPaymentIds = new Set(committedVoucherPayments.filter(payment => hasSyncedOrderPaymentRecord(payment)).map(payment => String(payment.order_payment_id)));
+    const committedVoucherIds = new Set(committedVoucherPayments.map(payment => String(payment.voucher_id)));
+    const replaceableVouchers = mappedVouchers.filter(payment => {
+      if (hasSyncedOrderPaymentRecord(payment) && committedVoucherPaymentIds.has(String(payment.order_payment_id))) {
+        return false;
+      }
+      if (payment.voucher_id !== undefined && committedVoucherIds.has(String(payment.voucher_id))) {
+        return false;
+      }
+      return true;
+    });
+    const cappedVouchers = this.capVoucherPaymentsByRemainingAmount({
+      vouchers: replaceableVouchers,
+      nonVoucherPayments: [...nonVoucherPayments, ...committedVoucherPayments]
+    });
+    tempOrder.payments = [...nonVoucherPayments, ...committedVoucherPayments, ...cappedVouchers];
+    this.updateTempOrderPaymentStatus(tempOrder);
+    this.persistTempOrder();
+    void this.recalculateSummary({
+      createIfMissing: true
+    }).catch(error => {
+      this.logError('recalculate summary after updateVoucherOrderPayments failed', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    return tempOrder.payments;
+  }
+  async shouldMergeProductToOrder(params) {
+    const onBeforeMergeProductToOrder = this.orderHooks?.onBeforeMergeProductToOrder;
+    if (!onBeforeMergeProductToOrder) return true;
+    const result = await onBeforeMergeProductToOrder({
+      ...params,
+      defaultShouldMerge: true
+    });
+    if (typeof result === 'boolean') return result;
+    if (result && typeof result === 'object' && typeof result.shouldMerge === 'boolean') {
+      return result.shouldMerge;
+    }
+    return true;
+  }
+  hasOrderProductLineNote(product) {
+    return typeof product?.note === 'string' && product.note.trim().length > 0;
+  }
+
+  /**
+   * 判断商品行是否显式绑定了 booking。
+   *
+   * @example
+   * this.hasLinkedBookingUid({ metadata: { booking_uid: 'booking-1' } });
+   */
+  hasLinkedBookingUid(product) {
+    const bookingUid = product?.booking_uid ?? product?.metadata?.booking_uid;
+    return bookingUid !== undefined && bookingUid !== null && String(bookingUid) !== '';
+  }
+
+  // ─── TempOrder: 商品 CRUD ───
+
+  /**
+   * 预约商品加车后的统一收尾：促销、折扣、summary 重算与持久化（批量拆行时只调用一次）。
+   *
+   * @example
+   * await this.finalizeProductOrderMutation(tempOrder);
+   */
+  async finalizeProductOrderMutation(tempOrder, options) {
+    this.syncTempOrderHolderFromBookings(tempOrder);
+    if (!options?.skipEditDiscountConfigRefresh) {
+      await this.ensureEditDiscountConfigForProductChange(tempOrder);
+    }
+    if (!options?.skipDiscountRecalculation) {
+      await this.applyPromotion();
+    }
+    if (!options?.skipDiscountRecalculation) {
+      this.applyDiscount();
+    }
+    this.sanitizeTempOrderProducts(tempOrder);
+    await this.recalculateSummary({
+      createIfMissing: true
+    });
+    this.persistTempOrder();
+  }
+
+  /**
+   * 向 tempOrder 追加一条商品行（及可选 booking），不触发 summary 重算。
+   * 带 booking 且 num>1 时由 `addProductToOrder` 拆成多次本方法调用（每次 num=1）。
+   *
+   * @example
+   * await this.appendProductLineToTempOrder(tempOrder, { product_id: 1, num: 1 }, booking);
+   */
+  async appendProductLineToTempOrder(tempOrder, product, booking) {
+    const linked = booking ? this.createLinkedProductAndBooking({
+      product,
+      booking
+    }) : null;
+    const productToAdd = linked?.product || product;
+    const incomingFingerprint = (0, _utils3.buildProductLineFingerprint)((0, _utils.getProductSkuOptions)(productToAdd), productToAdd.product_bundle);
+    const normalizedIncoming = (0, _utils.mergeOrderProductDisplayFields)(productToAdd, (0, _utils3.normalizeOrderProduct)(productToAdd));
+    const incomingBookingUid = productToAdd.booking_uid ?? productToAdd.metadata?.booking_uid;
+    if (incomingBookingUid !== undefined && incomingBookingUid !== null && String(incomingBookingUid) !== '') {
+      normalizedIncoming.booking_uid = String(incomingBookingUid);
+      normalizedIncoming.metadata = {
+        ...(normalizedIncoming.metadata || {}),
+        booking_uid: String(incomingBookingUid)
+      };
+    }
+    normalizedIncoming.discount_list = (0, _utils.normalizeOrderProductDiscountList)(normalizedIncoming.discount_list);
+    const hasIncomingGoodPass = this.hasGoodPassDiscount(normalizedIncoming);
+    const hasIncomingProductNote = this.hasOrderProductLineNote(normalizedIncoming);
+    const hasIncomingBookingUid = this.hasLinkedBookingUid(productToAdd) || this.hasLinkedBookingUid(normalizedIncoming);
+    const shouldForceNewLine = !!booking || hasIncomingProductNote || hasIncomingBookingUid;
+    const matchedIndex = hasIncomingGoodPass || shouldForceNewLine ? -1 : tempOrder.products.findIndex(item => {
+      if (this.hasGoodPassDiscount(item)) return false;
+      if (this.hasOrderProductLineNote(item)) return false;
+      if (item.order_detail_id !== undefined && item.order_detail_id !== null) return false;
+      if (item.metadata?.is_edit_for_runtime) return false;
+      if (item.product_id !== productToAdd.product_id) return false;
+      if (item.product_variant_id !== productToAdd.product_variant_id) return false;
+      const existedFingerprint = (0, _utils3.buildProductLineFingerprint)((0, _utils.getProductSkuOptions)(item), item.product_bundle);
+      return existedFingerprint === incomingFingerprint;
+    });
+    const matchedProduct = matchedIndex === -1 ? null : tempOrder.products[matchedIndex];
+    const existedFingerprint = matchedProduct ? (0, _utils3.buildProductLineFingerprint)((0, _utils.getProductSkuOptions)(matchedProduct), matchedProduct.product_bundle) : '';
+    const shouldMerge = matchedProduct ? await this.shouldMergeProductToOrder({
+      incomingProduct: productToAdd,
+      normalizedIncoming,
+      matchedProduct,
+      matchedIndex,
+      incomingFingerprint,
+      existedFingerprint,
+      tempOrder,
+      booking
+    }) : false;
+    if (matchedIndex === -1 || !matchedProduct || !shouldMerge) {
+      this.captureProductRuntime(tempOrder, productToAdd, normalizedIncoming);
+      if (linked) {
+        normalizedIncoming.booking_uid = linked.bookingUid;
+        normalizedIncoming.metadata = {
+          ...(normalizedIncoming.metadata || {}),
+          booking_uid: linked.bookingUid
+        };
+      }
+      // tempOrder.products.push(normalizedIncoming);
+      tempOrder.products = [...tempOrder.products, normalizedIncoming];
+    } else {
+      const targetProduct = matchedProduct;
+      const targetUid = targetProduct.metadata?.unique_identification_number;
+      const normalizedProduct = (0, _utils.mergeOrderProductDisplayFields)(targetProduct, (0, _utils3.normalizeOrderProduct)({
+        ...productToAdd,
+        metadata: {
+          ...(productToAdd.metadata || {}),
+          unique_identification_number: targetUid
+        }
+      }));
+      normalizedProduct.discount_list = (0, _utils.normalizeOrderProductDiscountList)(normalizedProduct.discount_list);
+      const nextNum = (0, _utils3.getSafeProductNum)(targetProduct.num + normalizedProduct.num);
+      const targetIsManualProductDiscount = isManualProductDiscountProduct(targetProduct);
+      const nextDiscountList = targetIsManualProductDiscount ? (0, _utils.normalizeOrderProductDiscountList)((0, _manualProductDiscount.syncManualProductDiscountProductNum)(targetProduct.discount_list, nextNum)) : normalizedProduct.discount_list;
+      tempOrder.products[matchedIndex] = {
+        ...targetProduct,
+        ...normalizedProduct,
+        discount_list: nextDiscountList,
+        metadata: {
+          ...(targetProduct.metadata || {}),
+          ...(normalizedProduct.metadata || {}),
+          unique_identification_number: targetUid
+        },
+        product_sku: {
+          ...(targetProduct.product_sku || {
+            option: []
+          }),
+          ...(normalizedProduct.product_sku || {
+            option: []
+          }),
+          option: (0, _utils.getProductSkuOptions)(normalizedProduct)
+        },
+        ...(targetIsManualProductDiscount ? {
+          selling_price: targetProduct.selling_price,
+          original_price: targetProduct.original_price,
+          payment_price: targetProduct.payment_price,
+          metadata: {
+            ...(normalizedProduct.metadata || {}),
+            ...(targetProduct.metadata || {}),
+            unique_identification_number: targetUid
+          }
+        } : {}),
+        note: targetProduct.note,
+        order_detail_id: targetProduct.order_detail_id,
+        num: nextNum
+      };
+      this.captureProductRuntime(tempOrder, productToAdd, tempOrder.products[matchedIndex], targetUid);
+    }
+    if (linked) {
+      tempOrder.bookings = [...(tempOrder.bookings || []), linked.booking];
+    }
+  }
+
+  /**
+   * 添加商品行。带 booking 时强制独立行；num>1 时拆成多条 num=1 的 product+booking（对齐 BookingByStep / ticketBooking addService）。
+   *
+   * @example
+   * await order.addProductToOrder({ product_id: 1, num: 3 }, { start_time: '10:00' });
+   * // → tempOrder.products 新增 3 行，每行 num=1，bookings 3 条
+   */
+  async addProductToOrder(product, booking) {
+    const tempOrder = this.ensureTempOrder();
+    if (booking) {
+      const productRecord = product;
+      const splitCount = (0, _utils3.getSafeProductNum)(productRecord.num ?? productRecord.product_quantity ?? 1);
+      if (splitCount > 1) {
+        for (let i = 0; i < splitCount; i += 1) {
+          const singleLine = (0, _lodashEs.cloneDeep)(productRecord);
+          singleLine.num = 1;
+          delete singleLine.product_quantity;
+          await this.appendProductLineToTempOrder(tempOrder, singleLine, (0, _lodashEs.cloneDeep)(booking));
+        }
+        await this.finalizeProductOrderMutation(tempOrder);
+        return tempOrder.products;
+      }
+    }
+    await this.appendProductLineToTempOrder(tempOrder, product, booking);
+    await this.finalizeProductOrderMutation(tempOrder);
+    this.logInfo('addProductToOrder success', {
+      product_id: product.product_id,
+      with_booking: !!booking
+    });
+    return tempOrder.products;
+  }
+
+  /**
+   * 批量添加商品行，所有行追加完成后只触发一次促销、折扣、summary 重算与持久化。
+   *
+   * @example
+   * await order.addProductsToOrder([
+   *   { product: { product_id: 1, product_variant_id: 0, num: 1 } },
+   *   { product: { product_id: 2, product_variant_id: 0, num: 1 } },
+   * ]);
+   */
+  async addProductsToOrder(items, options) {
+    const tempOrder = this.ensureTempOrder();
+    if (!Array.isArray(items) || items.length === 0) return tempOrder.products;
+    for (const item of items || []) {
+      const {
+        product,
+        booking
+      } = item;
+      if (!product) continue;
+      if (booking) {
+        const productRecord = product;
+        const splitCount = (0, _utils3.getSafeProductNum)(productRecord.num ?? productRecord.product_quantity ?? 1);
+        if (splitCount > 1) {
+          for (let i = 0; i < splitCount; i += 1) {
+            const singleLine = (0, _lodashEs.cloneDeep)(productRecord);
+            singleLine.num = 1;
+            delete singleLine.product_quantity;
+            await this.appendProductLineToTempOrder(tempOrder, singleLine, (0, _lodashEs.cloneDeep)(booking));
+          }
+          continue;
+        }
+      }
+      await this.appendProductLineToTempOrder(tempOrder, product, booking);
+    }
+    await this.finalizeProductOrderMutation(tempOrder, options);
+    this.logInfo('addProductsToOrder success', {
+      itemsCount: items.length
+    });
+    return tempOrder.products;
+  }
+  hasGoodPassDiscount(product) {
+    const hasMainGoodPass = (product.discount_list || []).some(item => item?.type === 'good_pass' || item?.tag === 'good_pass');
+    if (hasMainGoodPass) return true;
+    const bundleDiscountList = [];
+    (product.product_bundle || []).forEach(item => {
+      bundleDiscountList.push(...(item?.discount_list || []));
+    });
+    (product?._extend?.other?.bundle || []).forEach(item => {
+      bundleDiscountList.push(...(item?.discount_list || []));
+    });
+    return bundleDiscountList.some(item => item?.type === 'good_pass' || item?.tag === 'good_pass');
+  }
+  getBundleRuntimeIdentity(bundle) {
+    if (!bundle || typeof bundle !== 'object') return '';
+    return [bundle.bundle_id ?? bundle.id ?? '', bundle.bundle_group_id ?? bundle.group_id ?? '', bundle.bundle_product_id ?? bundle._bundle_product_id ?? bundle.product_id ?? '', bundle.bundle_variant_id ?? bundle.product_variant_id ?? 0].join('|');
+  }
+  preservePersistedBundlePriceFields(previousBundles, nextBundles) {
+    if (!Array.isArray(nextBundles)) return nextBundles;
+    if (!Array.isArray(previousBundles) || previousBundles.length === 0) return nextBundles;
+    const previousByIdentity = new Map();
+    previousBundles.forEach(bundle => {
+      const identity = this.getBundleRuntimeIdentity(bundle);
+      if (identity) previousByIdentity.set(identity, bundle);
+    });
+    return nextBundles.map((bundle, index) => {
+      if (!bundle || typeof bundle !== 'object') return bundle;
+      const previous = previousByIdentity.get(this.getBundleRuntimeIdentity(bundle)) || previousBundles[index];
+      if (!previous || typeof previous !== 'object') return bundle;
+      return {
+        ...bundle,
+        ...((bundle.cover === undefined || bundle.cover === null || bundle.cover === '') && previous.cover !== undefined && previous.cover !== null && previous.cover !== '' ? {
+          cover: previous.cover
+        } : {}),
+        price: previous.price,
+        custom_price: previous.custom_price,
+        bundle_payment_price: previous.bundle_payment_price,
+        bundle_selling_price: previous.bundle_selling_price,
+        original_price: previous.original_price,
+        product_price: previous.product_price
+      };
+    });
+  }
+  applyOrderProductUpdateToTempOrder(tempOrder, params) {
+    const {
+      product_id,
+      product_variant_id,
+      updates,
+      unique_identification_number,
+      identity_key,
+      product_sku,
+      product_bundle,
+      booking
+    } = params;
+    const identityLookup = {
+      product_id,
+      product_variant_id
+    };
+    if (unique_identification_number !== undefined) {
+      identityLookup.unique_identification_number = unique_identification_number;
+      if (identity_key === undefined) {
+        identityLookup.identity_key = unique_identification_number;
+      }
+    }
+    if (identity_key !== undefined) {
+      identityLookup.identity_key = identity_key;
+    }
+    if (product_sku !== undefined) identityLookup.product_sku = product_sku;
+    if (product_bundle !== undefined) identityLookup.product_bundle = product_bundle;
+    let productIndex = -1;
+    if (unique_identification_number !== undefined) {
+      const targetUid = String(unique_identification_number);
+      productIndex = tempOrder.products.findIndex(item => {
+        return String(item.metadata?.unique_identification_number || item.unique_identification_number || '') === targetUid;
+      });
+    }
+    if (productIndex === -1) {
+      productIndex = (0, _utils3.getProductIdentityIndex)(tempOrder.products, identityLookup);
+    }
+    if (productIndex === -1) {
+      throw new Error('[Order] 目标商品不存在，无法更新');
+    }
+    const targetProduct = tempOrder.products[productIndex];
+    const nextProduct = {
+      ...targetProduct,
+      ...updates,
+      product_id,
+      product_variant_id,
+      metadata: {
+        ...(targetProduct.metadata || {}),
+        ...(updates?.metadata || {}),
+        unique_identification_number: targetProduct.metadata?.unique_identification_number || unique_identification_number
+      },
+      product_sku: {
+        ...(targetProduct.product_sku || {
+          option: []
+        }),
+        ...(updates?.product_sku && typeof updates.product_sku === 'object' ? updates.product_sku : {}),
+        option: Array.isArray(updates?.product_sku?.option) ? updates.product_sku.option : (0, _utils.getProductSkuOptions)(targetProduct)
+      }
+    };
+    nextProduct.num = (0, _utils3.getSafeProductNum)(nextProduct.num);
+    // 兜底：caller 通过 updates 直接改了 selling_price / original_price 时，
+    // 视为 "重新给 source-level 主价"（caller 侧旧约定仍是 main-only 单价）。
+    // 清掉 metadata 里的 source_product_price / main_product_* / price_schema_version，
+    // 让 normalize 把顶层 selling_price 当作 source 来重算 main_original(=source+options) /
+    // main_selling / composite；否则旧 metadata 会反压顶层新值，触发口径不一致。
+    // 如果 caller 走推荐路径（updates.metadata.* 显式指定主价），保留 metadata 由 normalize 认它。
+    const callerUpdatesTopPrice = Object.prototype.hasOwnProperty.call(updates || {}, 'selling_price') || Object.prototype.hasOwnProperty.call(updates || {}, 'original_price');
+    const callerUpdatesMainMeta = updates?.metadata?.main_product_selling_price !== undefined || updates?.metadata?.main_product_original_price !== undefined || updates?.metadata?.source_product_price !== undefined;
+    const callerUpdatesSourcePrice = updates?.metadata?.source_product_price !== undefined;
+    const callerUpdatesMainSellingPrice = updates?.metadata?.main_product_selling_price !== undefined;
+    const callerUpdatesMainOriginalPrice = updates?.metadata?.main_product_original_price !== undefined;
+    const previousLineFingerprint = (0, _utils3.buildProductLineFingerprint)((0, _utils.getProductSkuOptions)(targetProduct), targetProduct.product_bundle);
+    const nextLineFingerprint = (0, _utils3.buildProductLineFingerprint)((0, _utils.getProductSkuOptions)(nextProduct), nextProduct.product_bundle);
+    const callerChangesVariant = Number(product_variant_id || 0) !== Number(targetProduct.product_variant_id || 0);
+    const callerChangesLineConfiguration = callerChangesVariant || previousLineFingerprint !== nextLineFingerprint;
+    const isPersistedOrderLine = targetProduct.order_detail_id !== undefined && targetProduct.order_detail_id !== null;
+    const callerChangesDiscountList = Array.isArray(updates?.discount_list) && updates.discount_list.length > 0 && !isSameDiscountList(updates.discount_list, targetProduct.discount_list);
+    const callerUpdatesManualPrice = updates?.metadata?.price_override !== undefined || updates?.metadata?.is_manual_discount !== undefined || updates?.metadata?.product_discount_reason !== undefined || callerChangesDiscountList;
+    const callerAllowsBookingReprice = (() => {
+      if (params.allow_booking_reprice !== true || !booking || !callerUpdatesTopPrice || !callerUpdatesMainMeta) {
+        return false;
+      }
+      const hasChangedPrice = (nextValue, currentValue) => {
+        if (nextValue === undefined || nextValue === null || nextValue === '') {
+          return false;
+        }
+        return !new _decimal.default(Number(nextValue) || 0).equals(new _decimal.default(Number(currentValue) || 0));
+      };
+      return hasChangedPrice(updates.selling_price, targetProduct.selling_price) || hasChangedPrice(updates.original_price, targetProduct.original_price);
+    })();
+    if (isPersistedOrderLine && !callerChangesLineConfiguration && !callerUpdatesManualPrice && !callerAllowsBookingReprice) {
+      nextProduct.selling_price = targetProduct.selling_price;
+      nextProduct.original_price = targetProduct.original_price;
+      nextProduct.payment_price = targetProduct.payment_price;
+      nextProduct.metadata = {
+        ...(nextProduct.metadata || {}),
+        source_product_price: targetProduct.metadata?.source_product_price,
+        main_product_selling_price: targetProduct.metadata?.main_product_selling_price,
+        main_product_original_price: targetProduct.metadata?.main_product_original_price,
+        price_schema_version: targetProduct.metadata?.price_schema_version ?? 2
+      };
+      nextProduct.product_bundle = this.preservePersistedBundlePriceFields(targetProduct.product_bundle, nextProduct.product_bundle);
+    } else if (callerChangesLineConfiguration && callerUpdatesSourcePrice && (!callerUpdatesMainSellingPrice || !callerUpdatesMainOriginalPrice)) {
+      // 新配置只传了 source 时，不能把未传的 main_product_* 从旧行继承下来。
+      // 以新 source + 新 option 重建券前价；券后价未显式提供时保留旧主商品折扣额。
+      const previousMainOriginal = new _decimal.default(Number(targetProduct.metadata?.main_product_original_price) || 0);
+      const previousMainSelling = new _decimal.default(Number(targetProduct.metadata?.main_product_selling_price) || previousMainOriginal.toNumber());
+      const preservedDiscount = previousMainOriginal.minus(previousMainSelling);
+      const nextMainOriginal = new _decimal.default(Number(updates.metadata.source_product_price) || 0).plus((0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(nextProduct)));
+      nextProduct.metadata = {
+        ...(nextProduct.metadata || {}),
+        source_product_price: String(updates.metadata.source_product_price),
+        main_product_original_price: callerUpdatesMainOriginalPrice ? String(updates.metadata.main_product_original_price) : nextMainOriginal.toDecimalPlaces(2).toFixed(2),
+        main_product_selling_price: callerUpdatesMainSellingPrice ? String(updates.metadata.main_product_selling_price) : nextMainOriginal.minus(preservedDiscount).toDecimalPlaces(2).toFixed(2),
+        price_schema_version: 2
+      };
+    } else if (callerChangesVariant && !callerUpdatesTopPrice && !callerUpdatesMainMeta) {
+      // variant 已变化但 caller 没有显式报价时，旧 v2 metadata 不能继续充当权威价格源。
+      // 清理后由 normalize 优先读取 metadata.origin.variant 中新 variant 的目录价；
+      // 顶层 original/selling 的旧差额仍会作为 legacy discount 迁移到新价格。
+      const existedMeta = nextProduct.metadata || {};
+      nextProduct.metadata = {
+        ...existedMeta
+      };
+      delete nextProduct.metadata.source_product_price;
+      delete nextProduct.metadata.main_product_selling_price;
+      delete nextProduct.metadata.main_product_original_price;
+      delete nextProduct.metadata.price_schema_version;
+    } else if (callerChangesLineConfiguration && !callerUpdatesTopPrice && !callerUpdatesMainMeta) {
+      // 仅 option / bundle 变化时，保留历史 source 和主商品折扣金额，
+      // 但必须让 original 与 selling 一起随新的 option 金额移动。
+      const previousOptionSum = (0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(targetProduct));
+      const nextOptionSum = (0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(nextProduct));
+      const previousMainOriginal = new _decimal.default(Number(targetProduct.metadata?.main_product_original_price ?? targetProduct.original_price ?? 0) || 0);
+      const previousMainSelling = new _decimal.default(Number(targetProduct.metadata?.main_product_selling_price ?? targetProduct.selling_price ?? previousMainOriginal.toNumber()) || 0);
+      const preservedDiscount = previousMainOriginal.minus(previousMainSelling);
+      const previousSource = targetProduct.metadata?.source_product_price != null ? new _decimal.default(Number(targetProduct.metadata.source_product_price) || 0) : previousMainOriginal.minus(previousOptionSum);
+      const nextMainOriginal = previousSource.plus(nextOptionSum);
+      nextProduct.metadata = {
+        ...(nextProduct.metadata || {}),
+        source_product_price: previousSource.toDecimalPlaces(2).toFixed(2),
+        main_product_original_price: nextMainOriginal.toDecimalPlaces(2).toFixed(2),
+        main_product_selling_price: nextMainOriginal.minus(preservedDiscount).toDecimalPlaces(2).toFixed(2),
+        price_schema_version: 2
+      };
+    } else if (callerUpdatesTopPrice && !callerUpdatesMainMeta) {
+      const existedMeta = nextProduct.metadata || {};
+      nextProduct.metadata = {
+        ...existedMeta
+      };
+      delete nextProduct.metadata.source_product_price;
+      delete nextProduct.metadata.main_product_selling_price;
+      delete nextProduct.metadata.main_product_original_price;
+      delete nextProduct.metadata.price_schema_version;
+    }
+    // normalizeOrderProduct 幂等：v2 metadata 存在 → 保留 main_product_* 折扣重算 composite；
+    // 否则 → 把顶层 selling_price 视作 source，派生 main_product_* 并写 price_schema_version: 2。
+    let normalizedProduct = (0, _utils.mergeOrderProductDisplayFields)(nextProduct, (0, _utils3.normalizeOrderProduct)(nextProduct));
+    normalizedProduct.discount_list = (0, _utils.normalizeOrderProductDiscountList)(normalizedProduct.discount_list);
+    const preservedBookingUid = nextProduct.booking_uid || nextProduct.metadata?.booking_uid || targetProduct.booking_uid || targetProduct.metadata?.booking_uid;
+    if (!booking && preservedBookingUid) {
+      normalizedProduct.booking_uid = preservedBookingUid;
+      normalizedProduct.metadata = {
+        ...(normalizedProduct.metadata || {}),
+        booking_uid: preservedBookingUid
+      };
+    }
+    if (booking) {
+      const productUid = String(normalizedProduct.metadata?.unique_identification_number || targetProduct.metadata?.unique_identification_number || unique_identification_number || (0, _utils.createUuidV4)());
+      normalizedProduct.metadata = {
+        ...(normalizedProduct.metadata || {}),
+        unique_identification_number: productUid
+      };
+      const linked = this.createLinkedProductAndBooking({
+        product: {
+          ...normalizedProduct,
+          unique_identification_number: productUid
+        },
+        booking
+      });
+      this.removeLinkedBookingsForProduct(tempOrder, targetProduct);
+      normalizedProduct = {
+        ...normalizedProduct,
+        booking_uid: linked.bookingUid,
+        metadata: {
+          ...(normalizedProduct.metadata || {}),
+          booking_uid: linked.bookingUid,
+          unique_identification_number: productUid
+        }
+      };
+      tempOrder.bookings = [...(tempOrder.bookings || []), linked.booking];
+    }
+    tempOrder.products[productIndex] = normalizedProduct;
+    this.syncTempOrderHolderFromBookings(tempOrder);
+    this.captureProductRuntime(tempOrder, updates, tempOrder.products[productIndex], tempOrder.products[productIndex].metadata?.unique_identification_number);
+    return tempOrder.products[productIndex].metadata?.unique_identification_number;
+  }
+  async updateOrderProduct(params) {
+    const tempOrder = this.ensureTempOrder();
+    const updatedProductUid = this.applyOrderProductUpdateToTempOrder(tempOrder, params);
+    await this.applyPromotion();
+    this.applyDiscount({
+      reapplyBookingDiscountProductUids: params.allow_booking_discount_reapply && updatedProductUid ? [String(updatedProductUid)] : undefined
+    });
+    this.sanitizeTempOrderProducts(tempOrder);
+    await this.recalculateSummary({
+      createIfMissing: true
+    });
+    this.persistTempOrder();
+    this.logInfo('updateOrderProduct success', {
+      params
+    });
+    return tempOrder.products;
+  }
+  async updateOrderProducts(paramsList) {
+    const tempOrder = this.ensureTempOrder();
+    if (!paramsList.length) {
+      return tempOrder.products;
+    }
+    const reapplyBookingDiscountProductUids = paramsList.reduce((acc, params) => {
+      const updatedProductUid = this.applyOrderProductUpdateToTempOrder(tempOrder, params);
+      // 批量改预约时间时，延迟到最后一次折扣计算里统一恢复已选预约折扣卡。
+      if (params.allow_booking_discount_reapply && updatedProductUid) {
+        acc.push(String(updatedProductUid));
+      }
+      return acc;
+    }, []);
+    await this.finalizeAfterProductsMutation(tempOrder, {
+      reapplyBookingDiscountProductUids: reapplyBookingDiscountProductUids.length ? reapplyBookingDiscountProductUids : undefined
+    });
+    this.logInfo('updateOrderProduct success', {
+      paramsList
+    });
+    return tempOrder.products;
+  }
+  async updateOrderProductQuantity(params) {
+    const {
+      product_id,
+      product_variant_id,
+      num,
+      unique_identification_number,
+      identity_key,
+      product_sku,
+      product_bundle
+    } = params;
+    const tempOrder = this.ensureTempOrder();
     const identityLookup = {
       product_id,
       product_variant_id
     };
+    if (unique_identification_number !== undefined) {
+      identityLookup.unique_identification_number = unique_identification_number;
+      if (identity_key === undefined) {
+        identityLookup.identity_key = unique_identification_number;
+      }
+    }
     if (identity_key !== undefined) identityLookup.identity_key = identity_key;
-    if (product_option_item !== undefined) identityLookup.product_option_item = product_option_item;
+    if (product_sku !== undefined) identityLookup.product_sku = product_sku;
     if (product_bundle !== undefined) identityLookup.product_bundle = product_bundle;
-    const productIndex = (0, _utils3.getProductIdentityIndex)(tempOrder.products, identityLookup);
+    let productIndex = -1;
+    if (unique_identification_number !== undefined) {
+      const targetUid = String(unique_identification_number);
+      productIndex = tempOrder.products.findIndex(item => {
+        return String(item.metadata?.unique_identification_number || item.unique_identification_number || '') === targetUid;
+      });
+    }
     if (productIndex === -1) {
-      throw new Error('[Order] 目标商品不存在，无法更新');
+      productIndex = (0, _utils3.getProductIdentityIndex)(tempOrder.products, identityLookup);
+    }
+    if (productIndex === -1) {
+      throw new Error('[Order] 目标商品不存在，无法更新数量');
     }
     const targetProduct = tempOrder.products[productIndex];
-    const nextProduct = {
+    const normalizedProduct = (0, _utils3.normalizeOrderProduct)({
       ...targetProduct,
+      num: (0, _utils3.getSafeProductNum)(num),
+      metadata: {
+        ...(targetProduct.metadata || {}),
+        unique_identification_number: targetProduct.metadata?.unique_identification_number || unique_identification_number
+      }
+    });
+    normalizedProduct.discount_list = (0, _utils.normalizeOrderProductDiscountList)(normalizedProduct.discount_list);
+    tempOrder.products[productIndex] = normalizedProduct;
+    await this.applyPromotion();
+    this.applyDiscount();
+    this.sanitizeTempOrderProducts(tempOrder);
+    await this.recalculateSummary({
+      createIfMissing: true
+    });
+    this.persistTempOrder();
+    this.logInfo('updateOrderProductQuantity success', {
+      params
+    });
+    return tempOrder.products;
+  }
+  updateOrderBooking(params) {
+    const {
+      unique_identification_number,
+      updates
+    } = params;
+    const tempOrder = this.ensureTempOrder();
+    const bookingUid = String(unique_identification_number || '');
+    const bookingIndex = this.findBookingIndexByUniqueIdentificationNumber(tempOrder, bookingUid);
+    if (!bookingUid || bookingIndex === -1) {
+      throw new Error('[Order] 目标 booking 不存在，无法更新');
+    }
+    const targetBooking = tempOrder.bookings[bookingIndex] || {};
+    const nextBooking = {
+      ...targetBooking,
       ...updates,
-      product_id,
-      product_variant_id
+      metadata: {
+        ...(targetBooking.metadata || {}),
+        ...(updates.metadata || {}),
+        unique_identification_number: bookingUid
+      }
     };
-    nextProduct.num = (0, _utils3.getSafeProductNum)(nextProduct.num);
-    // 兜底：caller 通过 updates 直接改了 selling_price / original_price 时，
-    // 视为 "重新给 source-level 主价"（caller 侧旧约定仍是 main-only 单价）。
-    // 清掉 metadata 里的 source_product_price / main_product_* / price_schema_version，
-    // 让 normalize 把顶层 selling_price 当作 source 来重算 main_original(=source+options) /
-    // main_selling / composite；否则旧 metadata 会反压顶层新值，触发口径不一致。
-    // 如果 caller 走推荐路径（updates.metadata.* 显式指定主价），保留 metadata 由 normalize 认它。
-    const callerUpdatesTopPrice = Object.prototype.hasOwnProperty.call(updates || {}, 'selling_price') || Object.prototype.hasOwnProperty.call(updates || {}, 'original_price');
-    const callerUpdatesMainMeta = updates?.metadata?.main_product_selling_price !== undefined || updates?.metadata?.main_product_original_price !== undefined || updates?.metadata?.source_product_price !== undefined;
-    if (callerUpdatesTopPrice && !callerUpdatesMainMeta) {
-      const existedMeta = nextProduct.metadata || {};
-      nextProduct.metadata = {
-        ...existedMeta
-      };
-      delete nextProduct.metadata.source_product_price;
-      delete nextProduct.metadata.main_product_selling_price;
-      delete nextProduct.metadata.main_product_original_price;
-      delete nextProduct.metadata.price_schema_version;
-    }
-    // normalizeOrderProduct 幂等：v2 metadata 存在 → 保留 main_product_* 折扣重算 composite；
-    // 否则 → 把顶层 selling_price 视作 source，派生 main_product_* 并写 price_schema_version: 2。
-    tempOrder.products[productIndex] = (0, _utils3.normalizeOrderProduct)(nextProduct);
-    this.applyDiscount();
+    this.syncBookingMetadataHolder(nextBooking, nextBooking.metadata);
+    nextBooking.is_all = (0, _utils.normalizeBookingIsAll)(nextBooking);
+    nextBooking.sub_type = (0, _utils.normalizeBookingSubType)(nextBooking);
+    tempOrder.bookings[bookingIndex] = nextBooking;
+    this.syncTempOrderHolderFromBookings(tempOrder);
+    this.persistTempOrder();
+    return tempOrder.bookings;
+  }
+
+  /**
+   * 商品行写路径收尾：促销 → 折扣 → 清洗 → summary → 持久化。
+   * 批量删除等多行变更场景只应调用一次，避免 N 次 applyPromotion。
+   *
+   * @example
+   * await this.finalizeAfterProductsMutation(tempOrder);
+   */
+  async finalizeAfterProductsMutation(tempOrder, options) {
+    this.syncTempOrderHolderFromBookings(tempOrder);
+    await this.applyPromotion();
+    this.applyDiscount({
+      reapplyBookingDiscountProductUids: options?.reapplyBookingDiscountProductUids
+    });
+    this.sanitizeTempOrderProducts(tempOrder);
     await this.recalculateSummary({
       createIfMissing: true
     });
     this.persistTempOrder();
+  }
+
+  /**
+   * 批量按 identity 删除购物车行，末尾仅一次促销重算。
+   *
+   * @example
+   * await order.removeProductsFromOrder([identityA, identityB]);
+   */
+  async removeProductsFromOrder(identities) {
+    const tempOrder = this.ensureTempOrder();
+    if (!identities.length) {
+      return tempOrder.products;
+    }
+    const productsBeforeRemove = tempOrder.products || [];
+    const bookingsBeforeRemove = tempOrder.bookings || [];
+    const matchedProducts = productsBeforeRemove.filter(item => {
+      return identities.some(identity => (0, _utils3.isIdentityMatch)(item, identity));
+    });
+    const removedProducts = [];
+    tempOrder.products = tempOrder.products.filter(item => {
+      const shouldRemove = identities.some(identity => (0, _utils3.isIdentityMatch)(item, identity));
+      if (shouldRemove) removedProducts.push(item);
+      return !shouldRemove;
+    });
+    for (const product of removedProducts) {
+      this.removeLinkedBookingsForProduct(tempOrder, product);
+    }
+    const linkedBookingUidsToRemove = new Set();
+    for (const product of matchedProducts) {
+      const productUid = product?.metadata?.unique_identification_number || product?.unique_identification_number;
+      const productBookingUid = product?.booking_uid || product?.metadata?.booking_uid;
+      const isAddTimeProduct = product?.metadata?.product_add_schedule_time !== undefined && product?.metadata?.product_add_schedule_time !== null;
+      if (isAddTimeProduct) continue;
+      if (productBookingUid !== undefined && productBookingUid !== null && productBookingUid !== '') {
+        linkedBookingUidsToRemove.add(String(productBookingUid));
+      }
+      if (productUid !== undefined && productUid !== null && productUid !== '') {
+        bookingsBeforeRemove.forEach(booking => {
+          const bookingUid = this.getBookingUniqueIdentificationNumber(booking);
+          if (bookingUid && String(booking?.product_uid || '') === String(productUid)) {
+            linkedBookingUidsToRemove.add(bookingUid);
+          }
+        });
+      }
+    }
+    if (linkedBookingUidsToRemove.size > 0) {
+      // 删除主预约商品时，同步移除挂在同一 booking_uid 下的加时商品，避免残留孤儿行。
+      tempOrder.products = (tempOrder.products || []).filter(line => {
+        const lineBookingUid = line?.metadata?.booking_uid || line?.booking_uid;
+        const isAddTimeProduct = line?.metadata?.product_add_schedule_time !== undefined && line?.metadata?.product_add_schedule_time !== null;
+        return !(isAddTimeProduct && lineBookingUid !== undefined && lineBookingUid !== null && linkedBookingUidsToRemove.has(String(lineBookingUid)));
+      });
+    }
+    await this.finalizeAfterProductsMutation(tempOrder);
+    this.logInfo('removeProductsFromOrder success', {
+      identities
+    });
     return tempOrder.products;
   }
   async removeProductFromOrder(identity) {
+    return this.removeProductsFromOrder([identity]);
+  }
+
+  /**
+   * 仅清空购物车行（products / bookings），不重置整单。
+   * 用于「仅清空商品」；客户、备注、支付等协议字段保持不变。
+   */
+  async clearOrderCartLines() {
     const tempOrder = this.ensureTempOrder();
-    tempOrder.products = tempOrder.products.filter(item => !(0, _utils3.isIdentityMatch)(item, identity));
+    tempOrder.products = [];
+    tempOrder.bookings = [];
+    this.syncTempOrderHolderFromBookings(tempOrder);
+    if (tempOrder._extend && typeof tempOrder._extend === 'object') {
+      tempOrder._extend = {
+        ...tempOrder._extend,
+        productsByUid: {}
+      };
+    }
+    await this.applyPromotion();
     this.applyDiscount();
+    this.sanitizeTempOrderProducts(tempOrder);
     await this.recalculateSummary({
       createIfMissing: true
     });
     this.persistTempOrder();
-    return tempOrder.products;
+    this.logInfo('clearOrderCartLines success', {});
+    return tempOrder;
   }
 
   // ─── TempOrder: 提交 ───
 
+  buildCurrentSubmitPayloadForLocalPrint(params) {
+    const tempOrder = this.ensureTempOrder();
+    this.persistTempOrder();
+    const payload = (0, _utils.buildSubmitPayload)({
+      tempOrder,
+      cacheId: params?.cacheId ?? this.cacheId,
+      platform: params?.platform || this.otherParams?.platform,
+      businessCode: params?.businessCode ?? this.otherParams?.businessCode ?? this.otherParams?.business_code,
+      channel: params?.channel,
+      type: params?.type,
+      summary: this.store.summary || (0, _utils.createEmptySummary)(),
+      enhance: nextPayload => ({
+        ...nextPayload,
+        order_number: tempOrder.order_number ?? nextPayload.order_number ?? null,
+        shop_order_number: tempOrder.shop_order_number ?? nextPayload.shop_order_number ?? null,
+        shop_full_order_number: tempOrder.shop_full_order_number ?? nextPayload.shop_full_order_number ?? null,
+        small_ticket_data_flag: 1
+      })
+    });
+    payload.created_at = undefined;
+    return payload;
+  }
+  async applyLocalPrintOrderNumbers(order) {
+    const tempOrder = this.ensureTempOrder();
+    if (!order || typeof order !== 'object') return tempOrder;
+    const shopOrderNumber = order.shop_order_number;
+    const shopFullOrderNumber = order.shop_full_order_number;
+    if (shopOrderNumber !== undefined && shopOrderNumber !== null && shopOrderNumber !== '') {
+      tempOrder.shop_order_number = String(shopOrderNumber);
+    }
+    if (shopFullOrderNumber !== undefined && shopFullOrderNumber !== null && shopFullOrderNumber !== '') {
+      tempOrder.shop_full_order_number = String(shopFullOrderNumber);
+    }
+    this.persistTempOrder();
+    await this.saveDraft();
+    return tempOrder;
+  }
+
+  /**
+   * 提交当前 Sales tempOrder。
+   *
+   * smallTicketDataFlag 用于 B 端 checkout 小票数据返回。PaymentModal 在支付提交时
+   * 应传 1，确保 /shop/order/sales/checkout 返回打印所需数据。
+   */
   async submitTempOrder(params) {
+    return this.runSubmitTempOrder(params);
+  }
+  async submitTempOrderAsync(params) {
+    return this.runSubmitTempOrder({
+      ...params,
+      syncMode: true
+    });
+  }
+  async runSubmitTempOrder(params) {
     const tempOrder = this.ensureTempOrder();
+    const shouldConfirmPendingVoucherPayments = params?.confirmPendingVoucherPayments !== false;
+    const hasPaymentOverride = params?.payments !== undefined;
+    const preparedPaymentOverride = hasPaymentOverride ? this.prepareVoucherPaymentsForSubmit(params?.payments || [], shouldConfirmPendingVoucherPayments) : undefined;
+    if (!hasPaymentOverride) {
+      if (shouldConfirmPendingVoucherPayments) {
+        this.confirmPendingVoucherPayments({
+          persist: false,
+          recalculateSummary: false
+        });
+      } else {
+        this.discardPendingVoucherPayments({
+          persist: false,
+          recalculateSummary: false
+        });
+      }
+    }
     this.persistTempOrder();
+    const latestSummary = (await this.recalculateSummary({
+      createIfMissing: true
+    })) || this.store.summary || (0, _utils.createEmptySummary)();
     const effectiveCacheId = params?.cacheId ?? this.cacheId;
+    const hasPaymentStatusOverride = params?.paymentStatus !== undefined;
+    const hasSmallTicketDataFlagOverride = params?.smallTicketDataFlag !== undefined;
+    const enhancePayload = hasPaymentOverride || hasPaymentStatusOverride || hasSmallTicketDataFlagOverride || params?.enhancePayload ? (payload, ctx) => {
+      const nextPayload = {
+        ...payload,
+        ...(hasPaymentOverride ? {
+          payments: preparedPaymentOverride || []
+        } : {}),
+        ...(hasPaymentStatusOverride && !shouldConfirmPendingVoucherPayments ? {
+          payment_status: params?.paymentStatus
+        } : {}),
+        ...(hasSmallTicketDataFlagOverride ? {
+          small_ticket_data_flag: params?.smallTicketDataFlag
+        } : {})
+      };
+      const enhancedPayload = params?.enhancePayload ? params.enhancePayload(nextPayload, ctx) : nextPayload;
+      return enhancedPayload;
+    } : undefined;
+    const submitSnapshot = this.getLastOrderSubmitSnapshot();
     const payload = (0, _utils.buildSubmitPayload)({
       tempOrder,
       cacheId: effectiveCacheId,
-      platform: params?.platform,
-      businessCode: params?.businessCode,
+      platform: params?.platform || this.otherParams?.platform,
+      businessCode: submitSnapshot.businessCode ?? params?.businessCode ?? this.otherParams?.businessCode ?? this.otherParams?.business_code,
       channel: params?.channel,
-      type: params?.type,
-      enhance: params?.enhancePayload
+      type: submitSnapshot.type ?? params?.type,
+      summary: latestSummary,
+      request_unique_idempotency_token: params?.request_unique_idempotency_token,
+      enhance: enhancePayload
     });
+    if (params?.syncMode) {
+      payload.sync_mode = true;
+    }
+    // TODO: 前端生成的时间现在是有问题的，后面要统一优化
+    if (!payload.created_at) {
+      payload.created_at = (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss');
+    }
+    await this.saveDraft();
     let result;
-    if (tempOrder.order_id) {
-      const products = (0, _utils.filterProductsForScanOrderMore)(payload.products);
-      const moreResult = await this.scanOrderMore({
-        query: {
-          order_id: tempOrder.order_id,
-          products: products,
-          request_unique_idempotency_token: payload.request_unique_idempotency_token
-        }
+    try {
+      this.logInfo('submitTempOrder calling sales checkout', {
+        orderId: payload.order_id,
+        externalSaleNumber: payload.external_sale_number,
+        requestUniqueIdempotencyToken: payload.request_unique_idempotency_token,
+        paymentStatus: payload.payment_status,
+        paymentsCount: payload.payments?.length || 0,
+        smallTicketDataFlag: payload.small_ticket_data_flag,
+        syncMode: payload.sync_mode
       });
-      if (moreResult.code === 200) {
-        result = {
-          data: {
-            order_id: tempOrder.order_id
-          }
-        };
-      }
-    } else {
-      result = await this.submitScanOrder({
+      result = await this.submitSalesOrder({
         query: payload
       });
+    } catch (error) {
+      const backendErrorResponse = this.extractSubmitErrorResponse(error);
+      if (backendErrorResponse) {
+        this.store.syncState = 'failed';
+        this.logSubmitBackendRejected(backendErrorResponse, payload);
+        return backendErrorResponse;
+      }
+      this.store.syncState = 'failed';
+      this.logError('submitTempOrder failed', {
+        error: error instanceof Error ? error.message : String(error),
+        orderId: payload.order_id,
+        externalSaleNumber: payload.external_sale_number,
+        paymentStatus: payload.payment_status,
+        paymentsCount: payload.payments?.length || 0
+      });
+      throw error;
+    }
+    if (this.isSubmitResponseRejected(result)) {
+      this.store.syncState = 'failed';
+      this.logSubmitBackendRejected(result, payload);
+      return result;
+    }
+    const submittedOrderId = this.extractOrderIdFromSubmitResult(result);
+    this.logInfo('runSubmitTempOrder: 提交成功', {
+      submittedOrderId,
+      result,
+      tempOrder: {
+        ...tempOrder,
+        _extend: undefined
+      }
+    });
+    if (submittedOrderId !== null && submittedOrderId !== undefined) {
+      tempOrder.order_id = submittedOrderId;
+      const resultRecord = result;
+      await this.markLocalOrderSynced(submittedOrderId, resultRecord?.data || resultRecord || {});
+    } else if (this.isLocalPendingSubmitResult(result)) {
+      this.store.syncState = 'local';
+    } else {
+      this.store.syncState = 'submitted';
     }
     return result;
   }
+  async markLocalOrderSynced(orderId, remoteOrder) {
+    const tempOrder = this.ensureTempOrder();
+    tempOrder.order_id = orderId;
+    this.applyRemoteOrderNumbersToTempOrder(tempOrder, remoteOrder);
+    this.store.lastOrderInfo = remoteOrder;
+    this.store.syncState = 'submitted';
+    this.persistTempOrder();
+    await this.saveDraft();
+  }
+  applyRemoteOrderNumbersToTempOrder(tempOrder, remoteOrder) {
+    const applyOrderNumber = key => {
+      const value = remoteOrder?.[key];
+      if (value !== undefined && value !== null && value !== '') {
+        tempOrder[key] = String(value);
+      }
+    };
+    applyOrderNumber('order_number');
+    applyOrderNumber('shop_order_number');
+    applyOrderNumber('shop_full_order_number');
+  }
+  isSubmitResponseRejected(response) {
+    const isErrorCode = response?.code !== undefined && response.code !== 200 && response.code !== '200';
+    const isErrorStatus = response?.status === false || typeof response?.status === 'number' && response.status >= 400;
+    const isErrorSuccess = response?.success === false;
+    return isErrorCode || isErrorStatus || isErrorSuccess;
+  }
+  isLocalPendingSubmitResult(response) {
+    const data = response?.data && typeof response.data === 'object' ? response.data : response;
+    return Number(data?.need_sync) === 1;
+  }
+  isSubmitErrorResponse(response) {
+    if (!response || typeof response !== 'object') return false;
+    return this.isSubmitResponseRejected(response) || response.message !== undefined || response.msg !== undefined || response.error !== undefined;
+  }
+  extractSubmitErrorResponse(error) {
+    const candidates = [error?.response?.data, error?.data, error?.response?.body, error?.body];
+    return candidates.find(candidate => this.isSubmitErrorResponse(candidate)) || null;
+  }
+  logSubmitBackendRejected(response, payload) {
+    this.logError('submitTempOrder backend rejected', {
+      response,
+      payload: {
+        order_id: payload.order_id,
+        external_sale_number: payload.external_sale_number,
+        payment_status: payload.payment_status,
+        paymentsCount: payload.payments?.length || 0
+      }
+    });
+  }
+  generateIdempotencyToken() {
+    const tempOrder = this.ensureTempOrder();
+    const token = this.buildPaymentSyncIdempotencyToken(tempOrder, tempOrder.payments);
+    return `${token}_${Date.now()}`;
+  }
+  async syncPaymentsToOrder(params) {
+    const tempOrder = this.ensureTempOrder();
+    const mappedPayments = (0, _utils.mapPaymentItemsToOrderPayments)(params.payments || []);
+    const shouldConfirmPendingVoucherPayments = params.confirmPendingVoucherPayments ?? params.submitWhenPaid === true;
+    const effectivePayments = shouldConfirmPendingVoucherPayments ? this.confirmPendingVoucherPaymentsInList(mappedPayments) : params.confirmPendingVoucherPayments === false ? this.discardPendingVoucherPaymentsFromList(mappedPayments) : mappedPayments;
+    const completion = this.getPaymentCompletion(effectivePayments);
+    const orderPaidPaymentTotal = this.calculateOrderPaidPaymentTotal(effectivePayments);
+    const paymentStatus = completion.isOrderFullyPaid ? params.paymentStatus || 'paid' : orderPaidPaymentTotal.gt(0) ? 'partially_paid' : 'payment_processing';
+    tempOrder.payments = effectivePayments;
+    tempOrder.payment_status = paymentStatus;
+    this.persistTempOrder();
+    await this.saveDraft();
+    if (!params.submitWhenPaid) {
+      return completion;
+    }
+    if (this.store.syncState === 'submitting') {
+      return completion;
+    }
+    this.store.syncState = 'submitting';
+    const paymentSyncIdempotencyToken = this.buildPaymentSyncIdempotencyToken(tempOrder, effectivePayments);
+    const submitParams = {
+      payments: effectivePayments,
+      paymentStatus,
+      smallTicketDataFlag: params.smallTicketDataFlag,
+      businessCode: params.businessCode,
+      channel: params.channel,
+      confirmPendingVoucherPayments: true,
+      enhancePayload: payload => {
+        const nextPayload = {
+          ...payload,
+          request_unique_idempotency_token: paymentSyncIdempotencyToken
+        };
+        return nextPayload;
+      }
+    };
+    const submitResult = params.checkoutSyncTaskEnabled === false ? await this.submitTempOrderAsync(submitParams) : await this.submitTempOrder(submitParams);
+    return {
+      ...completion,
+      submitResult
+    };
+  }
   createOrder(params) {
     const order = {
       type: params?.type || 'appointment_booking',
@@ -642,6 +3531,7 @@ class OrderModule extends _BaseModule.BaseModule {
           item._origin.duration = duration;
           item._origin.sub_type = durationType;
         }
+        item._origin.sub_type = (0, _utils.normalizeBookingSubType)(item._origin);
         const discountList = (0, _utils.getAllDiscountList)(item);
         item._origin.product.discount_list = discountList;
 
@@ -718,14 +3608,54 @@ class OrderModule extends _BaseModule.BaseModule {
     });
     return this.request.post(fetchUrl, params);
   }
+  async cancelOrder(params) {
+    if (!Array.isArray(params.order_ids) || params.order_ids.length === 0) {
+      throw new Error('取消订单失败：order_ids 不能为空');
+    }
+    const payload = {
+      order_ids: params.order_ids,
+      status: 'cancelled',
+      change_schedule_event_appointment_status: 1,
+      is_void: 1
+    };
+    this.logInfo('cancelOrder called', {
+      url: '/order/update-status',
+      method: 'PUT',
+      orderIdsCount: params.order_ids.length
+    });
+    return this.request.put('/order/update-status', payload, {
+      isShopApi: true
+    });
+  }
+  async changeBookingStatus(params) {
+    if (!params.booking_id) {
+      throw new Error('变更预约状态失败：booking_id 不能为空');
+    }
+    if (!params.appointment_status) {
+      throw new Error('变更预约状态失败：appointment_status 不能为空');
+    }
+    const url = `/schedule/booking/appointment-status/${params.booking_id}`;
+    const payload = {
+      appointment_status: params.appointment_status
+    };
+    this.logInfo('changeBookingStatus called', {
+      url,
+      method: 'PUT',
+      bookingId: params.booking_id,
+      appointmentStatus: params.appointment_status
+    });
+    return this.request.put(url, payload, {
+      isShopApi: true
+    });
+  }
 
   /**
    * Checkout 专用：创建订单到后端
-   * 
+   *
    * 专门为 Checkout 模块设计的订单创建方法，
-   * 直接调用 /order/checkout 接口创建订单
+   * 通过 OS Server 调用 checkout 接口创建订单
    * 接收已经处理好的订单数据，无需再处理购物车
-   * 
+   *
    * @param params Checkout 订单参数（已处理的订单数据）
    * @returns 后端返回的订单数据（包含订单ID等）
    */
@@ -774,7 +3704,7 @@ class OrderModule extends _BaseModule.BaseModule {
       }
       // 记录接口调用详情
       this.logInfo('Calling backend checkout API', {
-        url: '/order/checkout',
+        url: '/shop/order/checkout',
         orderType: orderData.type,
         platform: orderData.platform,
         isDeposit: orderData.is_deposit,
@@ -796,9 +3726,10 @@ class OrderModule extends _BaseModule.BaseModule {
         hasOrderId: !!orderData.order_id,
         smallTicketDataFlag: orderData.small_ticket_data_flag
       });
-
-      // 调用后端接口
-      const response = await this.request.post('/order/checkout', orderData);
+      const response = await this.request.post('/order/checkout', orderData, {
+        osServer: true,
+        customToast: () => {}
+      });
       this.logInfo('Order API called successfully', {
         response
       });
@@ -811,44 +3742,446 @@ class OrderModule extends _BaseModule.BaseModule {
       throw error;
     }
   }
-  async submitScanOrder(params) {
+  async submitSalesOrder(params) {
     const {
       url,
       query
     } = params;
     const fetchUrl = url || '/order/sales/checkout';
     return this.request.post(fetchUrl, query, {
+      osServer: true,
       customToast: () => {}
     });
   }
-  async scanOrderMore(params) {
-    const {
-      url,
-      query
-    } = params;
-    const fetchUrl = url || `/order/order/product/${query.order_id}`;
-    const requestBody = {
-      products: query.products,
-      request_unique_idempotency_token: query.request_unique_idempotency_token
-    };
-    return this.request.put(fetchUrl, requestBody, {
-      customToast: () => {}
+
+  /**
+   * 发送支付链接邮件。
+   *
+   * 调用前必须已经有远端 order_id。BaseSales 会在需要时先提交本地订单，
+   * OrderModule 只负责校验 order_ids 并调用 /order/batch-email。
+   */
+  async sendCustomerPayLink(params) {
+    const orderIds = params.order_ids || params.orderIds || [];
+    if (!orderIds.length) {
+      throw new Error('发送支付链接前必须先提交本地订单并取得订单 ID');
+    }
+    if (!params.emails?.length) {
+      throw new Error('发送支付链接需要至少一个邮箱');
+    }
+    return this.request.post('/order/batch-email', {
+      order_ids: orderIds,
+      notify_action: params.notify_action || 'order_payment_reminder',
+      emails: params.emails
     });
   }
-
-  // TODO 获取详情的接口
-  async getOrderInfoByRemote(order_id) {
-    // 读取到后端以后，存在 tempOrder 内的 lastOrderInfo
-    const res = await this.request.get(`/order/sales/${order_id}`, {
-      with: ['products', 'scheduleEvents']
+  async getSalesOrderByLookup(params) {
+    const lookup = params.lookup === undefined || params.lookup === null ? '' : String(params.lookup).trim();
+    if (!lookup) {
+      throw new Error('加载销售详情需要 lookup');
+    }
+    // 如果 lookup 是external_sale_number，则forceRemote强制为 false
+    if (lookup.startsWith('LOCAL_')) {
+      params.forceRemote = false;
+    }
+    const res = await this.request.get(`/order/sales/${encodeURIComponent(lookup)}`, {
+      with: ['products', 'bookings', 'payments', 'customer', 'summary', 'contacts_info'],
+      ...(params.forceRemote ? {
+        forceRemote: true
+      } : {})
+    }, {
+      osServer: true
     });
-    if (res.code === 200 && this.store.tempOrder) {
-      this.store.tempOrder.lastOrderInfo = res.data;
+    if (res.code === 200) {
+      this.store.lastOrderInfo = res.data;
     }
     return res;
   }
+
+  /**
+   * 把 sqlite / 后端返回的订单记录直接恢复为 tempOrder。
+   *
+   * 数据源应尽量返回 tempOrder 所需结构；这里仅做 SDK 运行必须字段兜底，
+   * 例如数组字段、商品行唯一值、价格 metadata、summary 派生状态和 _extend。
+   */
+  async hydrateTempOrderFromRecord(record, options) {
+    const sourceRaw = record && typeof record === 'object' && record.data && record.order_id == null ? record.data : record || {};
+    const identityReadySource = this.seedAnonymousBookingUidsFromProducts(sourceRaw);
+    const normalizedCollections = (0, _orderCollectionIdentity.normalizeOrderCollections)(identityReadySource);
+    const raw = normalizedCollections.order;
+    const hasIdentityChanges = Object.values(normalizedCollections.stats).some(stats => stats.backfilledUidCount > 0 || stats.collapsedDuplicateCount > 0 || stats.uidConflictCount > 0 || stats.anonymousRowCount > 0);
+    if (hasIdentityChanges) {
+      const identityLogMetadata = {
+        collections: normalizedCollections.stats,
+        uidRemapCount: normalizedCollections.uidRemaps.length
+      };
+      const hasIdentityWarnings = Object.values(normalizedCollections.stats).some(stats => stats.uidConflictCount > 0 || stats.anonymousRowCount > 0);
+      if (hasIdentityWarnings) {
+        this.logWarning('Normalized hydrated order collection identities', identityLogMetadata);
+      } else {
+        this.logInfo('Normalized hydrated order collection identities', identityLogMetadata);
+      }
+    }
+    const nextTempOrder = this.normalizeTempOrderForRuntime(raw, {
+      makeEditMark: true
+    });
+    const rawSummary = raw.summary && typeof raw.summary === 'object' ? raw.summary : {};
+    const summarySurcharges = Array.isArray(rawSummary.surcharges) ? rawSummary.surcharges.map(s => ({
+      ...(s || {})
+    })) : (0, _lodashEs.cloneDeep)(nextTempOrder.surcharges || []);
+    this.store.tempOrder = nextTempOrder;
+    this.store.summary = {
+      ...(0, _utils.createEmptySummary)(),
+      ...rawSummary,
+      surcharges: summarySurcharges
+    };
+    nextTempOrder._extend = {
+      ...(nextTempOrder._extend || {}),
+      originalSalesSnapshot: {
+        summary: (0, _lodashEs.cloneDeep)(this.store.summary),
+        products: (0, _lodashEs.cloneDeep)(nextTempOrder.products || []),
+        bookings: (0, _lodashEs.cloneDeep)(nextTempOrder.bookings || []),
+        payments: (0, _lodashEs.cloneDeep)(nextTempOrder.payments || []),
+        surcharges: (0, _lodashEs.cloneDeep)(nextTempOrder.surcharges || []),
+        shop_discount: nextTempOrder.shop_discount || '0.00',
+        productFingerprint: this.buildOrderProductsFingerprint(nextTempOrder.products || [])
+      }
+    };
+    // lastOrderInfo carries the exact backend snapshot used by deposit/type recovery.
+    // Runtime collection repair lives in tempOrder/originalSalesSnapshot and must not
+    // rewrite this protocol snapshot as a side effect of hydration.
+    this.store.lastOrderInfo = sourceRaw.lastOrderInfo || sourceRaw;
+    const hydratedEditDiscounts = this.collectHydratedEditDiscounts(nextTempOrder.products);
+    const currentDiscounts = typeof this.store.discount?.getDiscountList === 'function' ? this.store.discount.getDiscountList() || [] : [];
+    const currentScanDiscounts = currentDiscounts.filter(discount => discount?.isScan);
+    const hydratedDiscountIds = new Set(hydratedEditDiscounts.map(discount => discount?.id));
+    const retainedScanDiscounts = currentScanDiscounts.filter(discount => !hydratedDiscountIds.has(discount?.id));
+    const nextDiscounts = [...hydratedEditDiscounts, ...retainedScanDiscounts];
+    const shouldSkipEmptyDiscountSync = nextDiscounts.length === 0 && currentDiscounts.length === 0;
+    if (!shouldSkipEmptyDiscountSync) {
+      OrderModule.populateSavedAmounts(nextTempOrder.products, nextDiscounts);
+      await this.store.discount?.setOriginalDiscountList(nextDiscounts);
+      await this.store.discount?.setDiscountList(nextDiscounts);
+    }
+    if (options?.recalcOnHydrate) {
+      await this.recalculateSummary({
+        createIfMissing: false
+      });
+    }
+    this.persistTempOrder();
+    return nextTempOrder;
+  }
+
+  /**
+   * 兼容后端详情将 holder 放在 metadata.holder 的历史形态，统一补到运行时展示路径。
+   *
+   * @example
+   * this.normalizeHydratedBookingHolder({ metadata: { holder: { form_record: [1] } } });
+   */
+  normalizeHydratedBookingHolder(booking) {
+    const next = {
+      ...(booking || {})
+    };
+    const metadata = next.metadata && typeof next.metadata === 'object' && !Array.isArray(next.metadata) ? {
+      ...next.metadata
+    } : {};
+    const metadataHolder = metadata.holder && typeof metadata.holder === 'object' && !Array.isArray(metadata.holder) ? metadata.holder : null;
+
+    // 编辑详情接口可能只返回 metadata.holder；UI 与提交链路统一读取 booking.holder。
+    if (!next.holder && metadataHolder) {
+      next.holder = {
+        ...metadataHolder
+      };
+    }
+    const holder = next.holder && typeof next.holder === 'object' && !Array.isArray(next.holder) ? next.holder : null;
+    const holderRecords = Array.isArray(holder?.form_record) ? holder.form_record.filter(id => id !== undefined && id !== null && id !== '') : [];
+    const hasMetadataHolderId = metadata.holder_id !== undefined && metadata.holder_id !== null && metadata.holder_id !== '' && (!Array.isArray(metadata.holder_id) || metadata.holder_id.length > 0);
+
+    // 卡片和编辑抽屉会从 holder_id 进入展示/表单回显，缺失时由 holder.form_record 补齐。
+    if (!hasMetadataHolderId && holderRecords.length > 0) {
+      metadata.holder_id = holderRecords;
+    }
+    if (Object.keys(metadata).length > 0) {
+      next.metadata = metadata;
+    }
+    return next;
+  }
+
+  /**
+   * 匿名 booking 没有服务端行 ID 时，商品侧已有的 booking_uid 就是唯一可用的强引用。
+   * 在统一规范化生成 UUID 前先复用它；已落库 booking 仍按 schedule_event_id 派生稳定 UID。
+   */
+  seedAnonymousBookingUidsFromProducts(raw) {
+    if (!raw || typeof raw !== 'object') return {};
+    if (!Array.isArray(raw.bookings) || !Array.isArray(raw.products)) return raw;
+    const bookingUidsByProductUid = new Map();
+    for (const product of raw.products) {
+      const productUid = (0, _orderCollectionIdentity.getOrderCollectionUid)('product', product);
+      const bookingUid = product?.booking_uid || product?.metadata?.booking_uid;
+      if (!productUid || bookingUid === undefined || bookingUid === null || bookingUid === '') {
+        continue;
+      }
+      const candidates = bookingUidsByProductUid.get(productUid) || new Set();
+      candidates.add(String(bookingUid));
+      bookingUidsByProductUid.set(productUid, candidates);
+    }
+    if (bookingUidsByProductUid.size === 0) return raw;
+    const anonymousBookingCountByProductUid = new Map();
+    for (const booking of raw.bookings) {
+      if ((0, _orderCollectionIdentity.getOrderCollectionPersistentId)('booking', booking) || (0, _orderCollectionIdentity.getOrderCollectionUid)('booking', booking)) {
+        continue;
+      }
+      const productUid = booking?.product_uid || booking?.metadata?.product_uid;
+      if (productUid === undefined || productUid === null || productUid === '') continue;
+      const key = String(productUid);
+      anonymousBookingCountByProductUid.set(key, (anonymousBookingCountByProductUid.get(key) || 0) + 1);
+    }
+    return {
+      ...raw,
+      bookings: raw.bookings.map(booking => {
+        if ((0, _orderCollectionIdentity.getOrderCollectionPersistentId)('booking', booking) || (0, _orderCollectionIdentity.getOrderCollectionUid)('booking', booking)) {
+          return booking;
+        }
+        const productUid = booking?.product_uid || booking?.metadata?.product_uid;
+        if (productUid === undefined || productUid === null || productUid === '') {
+          return booking;
+        }
+        const productUidKey = String(productUid);
+        // 多条匿名 booking 共用同一商品引用时身份仍然不明确，不能借商品字段猜测合并。
+        if (anonymousBookingCountByProductUid.get(productUidKey) !== 1) {
+          return booking;
+        }
+        const bookingUidCandidates = bookingUidsByProductUid.get(productUidKey);
+        const bookingUid = bookingUidCandidates?.size === 1 ? [...bookingUidCandidates][0] : null;
+        return bookingUid ? (0, _orderCollectionIdentity.setOrderCollectionUid)('booking', booking, bookingUid) : booking;
+      })
+    };
+  }
+  normalizeTempOrderForRuntime(raw, options) {
+    const nextTempOrder = {
+      ...this.createDefaultTempOrderInstance(),
+      ...(raw || {})
+    };
+    // ES 列表详情使用 id 表示订单主键；OS 详情态统一依赖 order_id 驱动操作按钮。
+    if ((nextTempOrder.order_id === undefined || nextTempOrder.order_id === null) && raw?.id !== undefined && raw?.id !== null) {
+      nextTempOrder.order_id = raw.id;
+    }
+    delete nextTempOrder.summary;
+    delete nextTempOrder.lastOrderInfo;
+    delete nextTempOrder.discount_list;
+    delete nextTempOrder.shop_id;
+    delete nextTempOrder.create_date;
+    delete nextTempOrder.total_amount;
+    delete nextTempOrder.expect_amount;
+    delete nextTempOrder.paid_amount;
+    delete nextTempOrder.shop_note;
+    delete nextTempOrder.start_time;
+    delete nextTempOrder.tax_fee;
+    delete nextTempOrder.total_refund_amount;
+    delete nextTempOrder.holder_id;
+    nextTempOrder.metadata = raw.metadata && typeof raw.metadata === 'object' ? {
+      ...raw.metadata
+    } : {};
+    nextTempOrder.holder = raw.holder && typeof raw.holder === 'object' ? {
+      ...raw.holder
+    } : null;
+    const rawProducts = Array.isArray(raw.products) ? raw.products : [];
+    nextTempOrder.products = rawProducts.length > 0 ? rawProducts.map(p => this.normalizeHydratedOrderProduct(p, {
+      makeEditMark: options?.makeEditMark
+    })) : [];
+    nextTempOrder.bookings = Array.isArray(raw.bookings) ? raw.bookings.map(b => {
+      const booking = this.normalizeHydratedBookingHolder(b || {});
+      return {
+        ...booking,
+        is_all: (0, _utils.normalizeBookingIsAll)(booking),
+        sub_type: (0, _utils.normalizeBookingSubType)(booking)
+      };
+    }) : [];
+    nextTempOrder.payments = Array.isArray(raw.payments) ? raw.payments.map(p => ({
+      ...(p || {})
+    })) : [];
+    nextTempOrder.surcharges = Array.isArray(raw.surcharges) ? raw.surcharges.map(s => ({
+      ...(s || {})
+    })) : [];
+    nextTempOrder.relation_forms = Array.isArray(raw.relation_forms) ? raw.relation_forms.map(f => ({
+      ...(f || {})
+    })) : [];
+    nextTempOrder.contacts = Array.isArray(raw.contacts) ? raw.contacts.map(c => ({
+      ...(c || {})
+    })) : [];
+    nextTempOrder.contacts_info = raw.contacts_info && typeof raw.contacts_info === 'object' && !Array.isArray(raw.contacts_info) ? {
+      ...raw.contacts_info
+    } : null;
+    nextTempOrder._extend = raw._extend && typeof raw._extend === 'object' ? {
+      ...raw._extend,
+      productsByUid: raw._extend.productsByUid || {}
+    } : {
+      productsByUid: {}
+    };
+    const tempOrderExtend = nextTempOrder._extend;
+    const productsByUid = tempOrderExtend.productsByUid || {};
+    for (const [index, product] of nextTempOrder.products.entries()) {
+      const uid = product.metadata?.unique_identification_number;
+      if (!uid) continue;
+      const existed = productsByUid[uid] && typeof productsByUid[uid] === 'object' ? productsByUid[uid] : {};
+      const rawProduct = rawProducts[index] && typeof rawProducts[index] === 'object' ? rawProducts[index] : product;
+      const origin = existed.origin ?? rawProduct._origin ?? rawProduct.metadata?.origin ?? rawProduct;
+      const originSnapshot = (0, _lodashEs.cloneDeep)(origin);
+      const productOptionString = this.buildHydratedProductOptionString(rawProduct) || this.buildHydratedProductOptionString(product);
+      if (productOptionString && originSnapshot && typeof originSnapshot === 'object') {
+        if (originSnapshot.product_option_string === undefined) {
+          originSnapshot.product_option_string = productOptionString;
+        }
+        if (originSnapshot.product_options_stirng === undefined) {
+          originSnapshot.product_options_stirng = productOptionString;
+        }
+      }
+      productsByUid[uid] = {
+        ...existed,
+        origin: originSnapshot
+      };
+    }
+    tempOrderExtend.productsByUid = productsByUid;
+    this.hydrateLinkedBookingIdentity(nextTempOrder);
+    if (options?.ensureIdentity !== false) {
+      this.ensureExternalSaleNumber(nextTempOrder);
+    }
+    nextTempOrder.vouchers = raw.vouchers || [];
+    return nextTempOrder;
+  }
+  hydrateLinkedBookingIdentity(tempOrder) {
+    const bookingUidByProductUid = new Map();
+    const productByUid = new Map();
+    (tempOrder.products || []).forEach(product => {
+      const productUid = product?.metadata?.unique_identification_number || product?.unique_identification_number;
+      if (productUid !== undefined && productUid !== null && String(productUid) !== '') {
+        productByUid.set(String(productUid), product);
+      }
+    });
+    (tempOrder.bookings || []).forEach(booking => {
+      if (!booking || typeof booking !== 'object') return;
+      if (!booking.metadata || typeof booking.metadata !== 'object') {
+        booking.metadata = {};
+      }
+      const productUid = booking.product_uid || booking.metadata.product_uid;
+      if (productUid === undefined || productUid === null || String(productUid) === '') return;
+      const matchedProduct = productByUid.get(String(productUid));
+      const existedProductBookingUid = matchedProduct?.booking_uid || matchedProduct?.metadata?.booking_uid;
+      // 客户端订单详情可能缺少 booking 自身 uid，这里补齐后才能反写到商品行。
+      const bookingUid = String(booking.metadata.unique_identification_number || existedProductBookingUid || (0, _utils.createUuidV4)());
+      booking.metadata.unique_identification_number = bookingUid;
+      bookingUidByProductUid.set(String(productUid), bookingUid);
+    });
+    (tempOrder.products || []).forEach(product => {
+      const productUid = product?.metadata?.unique_identification_number || product?.unique_identification_number;
+      if (productUid === undefined || productUid === null || String(productUid) === '') return;
+      const bookingUid = bookingUidByProductUid.get(String(productUid));
+      if (!bookingUid) return;
+      if (!product.metadata || typeof product.metadata !== 'object') {
+        product.metadata = {};
+      }
+      // booking 已经过统一身份规范化；以它为准同步商品侧旧引用，避免两侧 UID 断链。
+      const linkedBookingUid = String(bookingUid);
+      product.booking_uid = linkedBookingUid;
+      product.metadata.booking_uid = linkedBookingUid;
+    });
+    this.syncLinkedBookingHoldersToProducts(tempOrder);
+  }
+  pickHydratedDisplayText(value) {
+    if (value === undefined || value === null) return '';
+    if (typeof value === 'string') return value;
+    if (typeof value !== 'object') return String(value);
+    return value.auto || value.original || value.en || value['zh-CN'] || value['zh-HK'] || '';
+  }
+  formatHydratedNamePair(group, item) {
+    const groupText = this.pickHydratedDisplayText(group);
+    const itemText = this.pickHydratedDisplayText(item);
+    if (groupText && itemText) return `${groupText}:${itemText}`;
+    return groupText || itemText;
+  }
+  buildHydratedProductOptionString(product) {
+    const segments = [];
+    const sku = product?.product_sku || {};
+    if (Array.isArray(sku.variant)) {
+      for (const variant of sku.variant) {
+        const segment = this.formatHydratedNamePair(variant?.group, variant?.item);
+        if (segment) segments.push(segment);
+      }
+    }
+    return segments.join(', ');
+  }
+  normalizeHydratedProductOptionItem(optionItem) {
+    const rawNum = optionItem?.num ?? optionItem?.quantity ?? 1;
+    const parsedNum = Number(rawNum);
+    const rawPrice = optionItem?.add_price ?? optionItem?.price ?? 0;
+    const parsedPrice = Number(rawPrice);
+    const normalized = {
+      ...optionItem,
+      option_group_item_id: optionItem?.option_group_item_id,
+      option_group_id: optionItem?.option_group_id,
+      num: Number.isFinite(parsedNum) && parsedNum > 0 ? parsedNum : 1,
+      add_price: Number.isFinite(parsedPrice) ? parsedPrice : 0
+    };
+    delete normalized.price;
+    if (optionItem?.name !== undefined) normalized.name = optionItem.name;
+    if (optionItem?.group_name !== undefined) normalized.group_name = optionItem.group_name;
+    if (optionItem?.id !== undefined) normalized.id = optionItem.id;
+    return normalized;
+  }
+  normalizeHydratedOrderProduct(product, options) {
+    let row = {
+      ...(product || {})
+    };
+    if (row.num === undefined && row.product_quantity !== undefined) {
+      row.num = row.product_quantity;
+    }
+    const productSku = (0, _utils.ensureProductSku)(row);
+    row.product_sku = {
+      ...productSku,
+      option: (0, _utils.normalizeProductSkuOptions)(productSku.option.map(optionItem => this.normalizeHydratedProductOptionItem(optionItem || {})))
+    };
+    delete row[`product_${'option'}_item`];
+    if (!Array.isArray(row.product_bundle)) row.product_bundle = [];
+    if (!row.metadata || typeof row.metadata !== 'object') row.metadata = {};
+    if (row.booking_uid && !row.metadata.booking_uid) {
+      row.metadata.booking_uid = row.booking_uid;
+    }
+    row = (0, _bundleDiscountHydration.restoreHydratedBundleDiscounts)(row, _utils.normalizeOrderProductDiscountList);
+    const existingIdentity = row.metadata.unique_identification_number || row.unique_identification_number;
+    if (!existingIdentity) {
+      row.metadata.unique_identification_number = (0, _utils.createUuidV4)();
+    }
+    // 从云端、本地数据库中获取到的商品数据，先打上 runtime 标记，提供给 UI 做 saved items.
+    if (options?.makeEditMark) {
+      row.metadata.is_edit_for_runtime = true;
+    }
+    const normalized = (0, _utils3.normalizeOrderProduct)(row);
+    normalized.discount_list = (0, _utils.normalizeOrderProductDiscountList)(normalized.discount_list);
+    const result = {
+      ...row,
+      ...normalized,
+      product_sku: normalized.product_sku,
+      metadata: {
+        ...row.metadata,
+        ...normalized.metadata
+      }
+    };
+    if (result.metadata) delete result.metadata.price_schema_version;
+    const restored = (0, _bundleDiscountHydration.restoreHydratedBundleDiscounts)(result, _utils.normalizeOrderProductDiscountList);
+    return this.sanitizeOrderProductForTempOrder(restored);
+  }
   getLastOrderInfo() {
-    return this.store?.tempOrder?.lastOrderInfo;
+    return this.store?.lastOrderInfo;
+  }
+  async getOrderInfo(order_id) {
+    const res = await this.request.get(`/order/sales/${order_id}`, {
+      with: ['products', 'bookings']
+    }, {
+      osServer: true
+    });
+    return res;
+  }
+  getVouchers() {
+    return this.store.tempOrder?.vouchers || [];
   }
 }
 exports.OrderModule = OrderModule;