@pisell/pisellos 2.2.309 → 2.2.311

package/lib/modules/Rules/index.js

@@ -11,6 +11,8 @@ var _utils2 = require("../Cart/utils");
 var _decimal = _interopRequireDefault(require("decimal.js"));
 var _lodashEs = require("lodash-es");
 var _dayjs = _interopRequireDefault(require("dayjs"));
+var _entitlementPass = require("../Discount/entitlementPass");
+var _availability = require("../Discount/availability");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class RulesModule extends _BaseModule.BaseModule {
   defaultName = 'rules';
@@ -49,12 +51,20 @@ class RulesModule extends _BaseModule.BaseModule {
   }
 
   /**
-   * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
-   * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+   * 商品未开启 Holder 选择时跳过匹配；已开启时，特定 form Holder 卡
+   * 只适用于同一 Holder Record，是否必填不影响匹配规则。
    */
-  checkHolderMatch(discount, product, holders) {
+  checkHolderMatch(discount, product, holderSource, holders) {
     // 非表单类型 holder 视为匹配
     if (discount.holder?.holder_type !== 'form') return true;
+
+    // getProduct 会裁剪商品字段，从原始商品读取配置，套餐子项沿用父商品。
+    const holderConfig = holderSource?.holder_config ?? holderSource?.metadata?.holder_config ?? holderSource?.origin?.holder_config ?? holderSource?.metadata?.origin?.holder_config ?? holderSource?._origin?.holder_config ?? holderSource?._extend?.holder_config ?? holderSource?._extend?.product?.holder_config ?? holderSource?._extend?.product?.metadata?.holder_config;
+    const holderStatus = holderConfig?.status;
+    const holderEnabled = holderStatus === true || ['enable', '1'].includes(String(holderStatus).trim().toLowerCase());
+    if (!holderEnabled || holderConfig?.resource_id === undefined || holderConfig?.resource_id === null || holderConfig?.resource_id === '') {
+      return true;
+    }
     const discountHolderIds = this.normalizeHolderRecordIds(discount.holder.holder_id);
     if (!discountHolderIds.length) return false;
     const productHolderIds = this.normalizeHolderRecordIds(product.holder_id);
@@ -94,10 +104,12 @@ class RulesModule extends _BaseModule.BaseModule {
         unavailableReason: _types.UnavailableReason.AlreadyUsed
       };
     }
+    const scannedEntitlementPassIds = newDiscountList.filter(discount => (0, _entitlementPass.isEntitlementPass)(discount)).map(discount => discount.id);
+    const scannedEntitlementPassIdSet = new Set(scannedEntitlementPassIds.map(String));
 
-    // 合并新旧折扣列表，并计算折扣结果,注意，如果旧折扣里有 isEditMode 为 true 的优惠券，则不合并
-    // 保留之前扫码得到的商品券（isScan: true）
-    const filteredOldDiscountList = oldDiscountList.filter(discount => !discount.isEditMode && (discount.tag !== 'good_pass' || discount.isScan));
+    // 客户次卡必须保留在完整列表中；同一实例以本次扫码数据更新。
+    // 历史折扣不参与试算，商品券继续沿用仅保留扫码来源的规则。
+    const filteredOldDiscountList = oldDiscountList.filter(discount => !discount.isEditMode && (!(0, _entitlementPass.isFullCoveragePass)(discount) || (0, _entitlementPass.isEntitlementPass)(discount) || discount.isScan) && !scannedEntitlementPassIdSet.has(String(discount.id)));
     const mergedDiscountList = (0, _utils.uniqueById)([...filteredOldDiscountList, ...newDiscountList]);
     const result = this.calcDiscount({
       discountList: mergedDiscountList,
@@ -106,7 +118,8 @@ class RulesModule extends _BaseModule.BaseModule {
       holders,
       isFormSubject
     }, {
-      scan: true
+      scan: true,
+      preferredEntitlementPassIds: scannedEntitlementPassIds
     });
 
     // 检查是否有产品使用了新折扣
@@ -206,6 +219,7 @@ class RulesModule extends _BaseModule.BaseModule {
     isFormSubject,
     orderTotalAmount
   }, options) {
+    const preferredEntitlementPassIds = new Set((options?.preferredEntitlementPassIds || []).map(String));
     const resolveIsFormSubject = product => typeof isFormSubject === 'function' ? Boolean(isFormSubject(product)) : Boolean(isFormSubject);
 
     // 识别出来是不是在编辑的界面里又新增了商品
@@ -223,7 +237,7 @@ class RulesModule extends _BaseModule.BaseModule {
       const uid = getOriginProductUid(originProduct);
       if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
       const discountType = selectedDiscount.tag || selectedDiscount.type;
-      return selectedDiscount.isEditMode === true && selectedDiscount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+      return selectedDiscount.isEditMode === true && selectedDiscount.isSelected === true && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType ?? '');
     };
     const resolveReapplyBookingDiscountPercent = (originProduct, selectedDiscount) => {
       if (!shouldReapplyBookingDiscount(originProduct, selectedDiscount)) return undefined;
@@ -240,7 +254,13 @@ class RulesModule extends _BaseModule.BaseModule {
       if (discount.isEditMode) {
         editModeDiscount.push(discount);
       } else {
-        addModeDiscount.push(discount);
+        // 试算不能把 config / 不可用原因写回原有选券；每次重新计算以清除旧原因。
+        addModeDiscount.push({
+          ...discount,
+          usageLimitFailKey: (0, _availability.getDiscountUsageLimitFailKey)(discount),
+          reason: undefined,
+          reasonCode: (0, _availability.getDiscountUsageBlockReason)(discount)
+        });
       }
     });
 
@@ -269,7 +289,7 @@ class RulesModule extends _BaseModule.BaseModule {
     }
     const canUseEditModeDiscountForReapply = discount => {
       const discountType = discount.tag || discount.type;
-      return reapplyBookingDiscountProductUids.size > 0 && discount.isEditMode === true && discount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+      return reapplyBookingDiscountProductUids.size > 0 && discount.isEditMode === true && discount.isSelected === true && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType ?? '');
     };
 
     // 过滤掉手动取消false的优惠券，但仅用于应用优惠逻辑。
@@ -343,6 +363,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
       // 辅助函数：判断是否是商品券
       const isGoodPass = discount => discount.tag === 'good_pass';
+      const isEntitlement = discount => (0, _entitlementPass.isEntitlementPass)(discount);
 
       // 辅助函数：判断是否是订单级折扣卡
       const isOrderLevelDiscount = discount => discount.tag === 'product_discount_card' && discount.metadata?.discount_calculation_mode === 'order_level';
@@ -404,6 +425,14 @@ class RulesModule extends _BaseModule.BaseModule {
         }
         return 0;
       }
+      const entitlementA = isEntitlement(a);
+      const entitlementB = isEntitlement(b);
+      if (entitlementA || entitlementB) {
+        if (entitlementA && entitlementB) {
+          return (0, _entitlementPass.compareEntitlementPassPriority)(a, b);
+        }
+        return entitlementA ? -1 : 1;
+      }
 
       // 1. 先按优先级排序
       const priorityA = getPriority(a);
@@ -472,19 +501,34 @@ class RulesModule extends _BaseModule.BaseModule {
 
     // 🔥 为每个折扣卡/商品券执行策略检查并附加config
     const evaluator = this.getWalletPassEvaluator();
+    addModeDiscount.forEach(discount => {
+      if (discount.reasonCode) discount.config = {
+        isAvailable: false
+      };
+    });
     if (evaluator) {
       addModeDiscount.forEach(discount => {
+        // 即使没有匹配的动态策略，服务端状态和次数限制也不能被覆盖为可用。
+        if (discount.reasonCode) return;
         const discountType = discount.tag || discount.type;
-        // 只对 good_pass 和 discount_card 类型执行策略检查
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
+        // 对两类全额抵扣卡和折扣卡执行附加策略检查。
+        if (['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType ?? '')) {
+          const entitlementQuota = (0, _entitlementPass.isEntitlementPass)(discount) ? (0, _entitlementPass.resolveEntitlementQuota)(discount) : null;
+          if ((0, _entitlementPass.isEntitlementPass)(discount) && !entitlementQuota) {
+            discount.config = {
+              isAvailable: false
+            };
+            return;
+          }
+
           // 转换 discount 为 Voucher 格式
           const voucher = {
             id: discount.id,
             amount: Number(discount.par_value || 0),
-            balance: Number(discount.balance || 0),
+            balance: entitlementQuota?.type === 'unlimited' ? Number.MAX_SAFE_INTEGER : entitlementQuota?.type === 'limited' ? entitlementQuota.balance : Number(discount.balance || 0),
             type: discountType,
             product_id: discount.product_id,
-            unified_available_status: 1,
+            unified_available_status: discount.unified_available_status ?? 1,
             available_product_type: discount.limited_relation_product_data?.type,
             available_product_ids: discount.limited_relation_product_data?.product_ids
           };
@@ -515,6 +559,8 @@ class RulesModule extends _BaseModule.BaseModule {
             discount.config = {
               isAvailable: false
             };
+            discount.reason = result.reason;
+            discount.reasonCode = result.reasonCode || 'not_meet_the_required_conditions';
           }
         }
       });
@@ -537,17 +583,126 @@ class RulesModule extends _BaseModule.BaseModule {
     });
      */
 
-    // 标记已使用的优惠券
+    // good_pass / 折扣卡保持原有的一次性使用标记。
     const usedDiscounts = new Map();
 
+    // Entitlement Pass 单独记录本次重算新增分配的次数。
+    const entitlementUsageCounts = new Map();
+
     // 🔥 统计每个 product_id（商品券商品id）已使用的数量，用于 maxUsagePerOrder 限制
     const usedProductIdCounts = new Map();
+    const markDiscountUsed = (discount, count = 1) => {
+      if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+        entitlementUsageCounts.set(discount.id, (entitlementUsageCounts.get(discount.id) || 0) + count);
+        return;
+      }
+      usedDiscounts.set(discount.id, true);
+    };
+    const isDiscountUsed = discount => {
+      if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+        return (entitlementUsageCounts.get(discount.id) || 0) > 0;
+      }
+      return usedDiscounts.get(discount.id) === true;
+    };
+    const buildFullCoveragePassUsageGroups = (discounts, requestedCount) => {
+      const groups = [];
+      const pendingUsedDiscounts = new Set(Array.from(usedDiscounts.entries()).filter(([, used]) => used).map(([discountId]) => discountId));
+      const pendingEntitlementCounts = new Map(entitlementUsageCounts);
+      const pendingProductCounts = new Map(usedProductIdCounts);
+      const firstGoodPass = discounts.find(discount => (0, _entitlementPass.isFullCoveragePass)(discount) && !(0, _entitlementPass.isEntitlementPass)(discount));
+      const legacyGoodPassPerLineLimit = firstGoodPass ? Number(firstGoodPass.config?.maxUsagePerOrder || 0) : 0;
+      let allocatedGoodPassCount = 0;
+      let remaining = Math.max(Math.floor(requestedCount), 0);
+      for (const discount of discounts) {
+        if (remaining <= 0) break;
+        if (!(0, _entitlementPass.isFullCoveragePass)(discount)) continue;
+        const currentEntitlementCount = pendingEntitlementCounts.get(discount.id) || 0;
+        let availableCount = (0, _entitlementPass.isEntitlementPass)(discount) ? (0, _entitlementPass.getRemainingEntitlementUses)(discount, currentEntitlementCount, remaining) : pendingUsedDiscounts.has(discount.id) ? 0 : 1;
+        if (!(0, _entitlementPass.isEntitlementPass)(discount) && legacyGoodPassPerLineLimit > 0) {
+          availableCount = Math.min(availableCount, Math.max(Math.floor(legacyGoodPassPerLineLimit) - allocatedGoodPassCount, 0));
+        }
+        const maxUsagePerOrder = Number(discount.config?.maxUsagePerOrder || 0);
+        if ((0, _entitlementPass.isEntitlementPass)(discount) && maxUsagePerOrder > 0) {
+          const currentProductCount = pendingProductCounts.get(discount.product_id) || 0;
+          availableCount = Math.min(availableCount, Math.max(Math.floor(maxUsagePerOrder) - currentProductCount, 0));
+        }
+        const allocatedCount = Math.min(availableCount, remaining);
+        if (allocatedCount <= 0) continue;
+        const existingGroup = groups.find(group => String(group.discount.id) === String(discount.id));
+        if (existingGroup) {
+          existingGroup.count += allocatedCount;
+        } else {
+          groups.push({
+            discount,
+            count: allocatedCount
+          });
+        }
+        if ((0, _entitlementPass.isEntitlementPass)(discount)) {
+          pendingEntitlementCounts.set(discount.id, currentEntitlementCount + allocatedCount);
+        } else {
+          pendingUsedDiscounts.add(discount.id);
+          allocatedGoodPassCount += allocatedCount;
+        }
+        pendingProductCounts.set(discount.product_id, (pendingProductCounts.get(discount.product_id) || 0) + allocatedCount);
+        remaining -= allocatedCount;
+      }
+      return groups;
+    };
+    const mergeEntitlementAppliedProductDetails = details => {
+      const mergedDetails = [];
+      const mergedIndexByKey = new Map();
+      const toComparableNumber = value => {
+        const numberValue = Number(value);
+        return Number.isFinite(numberValue) ? String(numberValue) : String(value ?? '');
+      };
+      for (const detail of details || []) {
+        if (!(0, _entitlementPass.isEntitlementPass)(detail)) {
+          mergedDetails.push(detail);
+          continue;
+        }
+        const resourceId = detail?.discount?.resource_id ?? detail?.resource_id;
+        if (resourceId === undefined || resourceId === null) {
+          mergedDetails.push(detail);
+          continue;
+        }
+        const key = [resourceId, detail?.discount?.product_id ?? '', detail?.metadata?.custom_product_bundle_map_id ?? '', toComparableNumber(detail?.amount), toComparableNumber(detail?.discount?.fixed_amount)].join('|');
+        const rawUsageCount = Number(detail?.metadata?.num ?? detail?._num ?? 1);
+        const usageCount = Number.isFinite(rawUsageCount) && rawUsageCount > 0 ? rawUsageCount : 1;
+        const mergedIndex = mergedIndexByKey.get(key);
+        if (mergedIndex === undefined) {
+          mergedIndexByKey.set(key, mergedDetails.length);
+          mergedDetails.push({
+            ...detail,
+            metadata: {
+              ...(detail?.metadata || {}),
+              num: usageCount
+            },
+            _num: usageCount
+          });
+          continue;
+        }
+        const existed = mergedDetails[mergedIndex];
+        const existedUsageCount = Number(existed?.metadata?.num ?? existed?._num ?? 1);
+        const totalUsageCount = existedUsageCount + usageCount;
+        mergedDetails[mergedIndex] = {
+          ...existed,
+          metadata: {
+            ...(existed?.metadata || {}),
+            num: totalUsageCount
+          },
+          _num: totalUsageCount
+        };
+      }
+      return mergedDetails;
+    };
 
     // 记录每个优惠券适用的商品ID
     const discountApplicability = new Map();
 
     // 记录每个优惠券适用的商品详细信息
     const discountApplicableProducts = new Map();
+    const discountTimeReasons = new Map();
+    const discountHolderMismatch = new Set();
 
     // 初始化每个优惠券的适用性和可抵扣商品
     addModeDiscount.forEach(discount => {
@@ -567,6 +722,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
     // 辅助函数：检查商品是否对某个折扣卡可用
     const checkItemApplicableForDiscount = (flatItem, discount) => {
+      if (discount.config?.isAvailable === false) return false;
       let product;
       if (flatItem.type === 'main') {
         product = flatItem.product;
@@ -587,7 +743,7 @@ class RulesModule extends _BaseModule.BaseModule {
       }
 
       // 编辑的商品使用了优惠券不可用
-      const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(d => d.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(d.tag || d.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(d => d.id));
+      const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(d => d.id && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(d.tag || d.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(d => d.id));
       if (!isAvailableProduct) {
         return false;
       }
@@ -771,30 +927,37 @@ class RulesModule extends _BaseModule.BaseModule {
         const isHolderMatch = this.checkHolderMatch(discount, {
           isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
           holder_id: _tempVar?.holder_id || product.holder_id
-        }, holders);
-        let timeLimit = true;
-        timeLimit = !!(0, _utils.filterDiscountListByBookingTime)([discount], (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
+        }, flatItem.originProduct, holders);
+        const timeReason = (0, _utils.getDiscountTimeUnavailableReason)(discount, (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss'));
+        const timeLimit = !timeReason;
         // 是符合折扣的商品
-        const isLimitedProduct = (limitedData.type === 'product_all' && limitedData.filter !== 1 || limitedData.type === 'product_all' && limitedData.filter === 1 && !limitedData.exclude_product_ids.includes(product.id) || limitedData.product_ids && limitedData.product_ids.includes(product.id)) && isHolderMatch;
+        const isProductInScope = limitedData.type === 'product_all' && limitedData.filter !== 1 || limitedData.type === 'product_all' && limitedData.filter === 1 && !limitedData.exclude_product_ids.includes(product.id) || limitedData.product_ids && limitedData.product_ids.includes(product.id);
+        const isLimitedProduct = isProductInScope && isHolderMatch;
 
         // 编辑的商品 使用了优惠券不可用
-        const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(discount => discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(discount => discount.id));
+        const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(discount => discount.id && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(discount => discount.id));
 
         // 套餐是否可用判断
         const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
+        if (isProductInScope && isBundleAvailable && !isItemRewardProductDiscount) {
+          const timeReasons = discountTimeReasons.get(discount.id) || [];
+          timeReasons.push(timeReason);
+          discountTimeReasons.set(discount.id, timeReasons);
+          if (!isHolderMatch && timeLimit) discountHolderMismatch.add(discount.id);
+        }
 
         // 判断优惠券是否适用于该商品
-        if (isAvailableProduct && !isItemRewardProductDiscount && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable) {
+        if (isAvailableProduct && !isItemRewardProductDiscount && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable && (!(0, _entitlementPass.isEntitlementPass)(discount) || (0, _entitlementPass.getRemainingEntitlementUses)(discount, 0, 1) > 0)) {
           // 记录此优惠券适用的商品
           discountApplicability.get(discount.id)?.push(product.id);
 
           // 记录可抵扣的商品详情
           const applicableProducts = discountApplicableProducts.get(discount.id) || [];
           const discountType = discount.tag || discount.type;
-          const isGoodPass = discountType === 'good_pass';
+          const isFullCoverage = (0, _entitlementPass.isFullCoveragePass)(discount);
 
           // 使用数量
-          const num = isGoodPass || flatItem?.type === 'main' ? 1 : product.num;
+          const num = isFullCoverage || flatItem?.type === 'main' ? 1 : product.num;
           const productData = {
             amount: product.price * num,
             type: discountType,
@@ -811,6 +974,7 @@ class RulesModule extends _BaseModule.BaseModule {
               discount_product_id: discount.product_id
             },
             metadata: {
+              encoded: discount.metadata?.encoded || discount.encoded,
               num: num,
               discount_rule_uncheck_flag: discount?.discount_rule_uncheck_flag
             }
@@ -912,7 +1076,7 @@ class RulesModule extends _BaseModule.BaseModule {
       const hasExistingWalletDiscount = product.discount_list?.length && product?.discount_list?.every(discount => {
         const discountIdentity = discount.id ?? discount.discount?.resource_id;
         const discountType = discount.tag || discount.type;
-        return Boolean(discountIdentity && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
+        return Boolean(discountIdentity && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
       });
 
       // 已持久化且已有钱包券/折扣卡的商品行跳过，保留后端历史折扣结果。
@@ -930,7 +1094,7 @@ class RulesModule extends _BaseModule.BaseModule {
       // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
       const applicableDiscounts = sortedDiscountList.filter(discount => {
         if (this.isItemRewardProductDiscount(product)) return false;
-        // 🔥 检查策略可用性（针对 good_pass 和折扣卡）
+        // 🔥 检查策略可用性（针对全额抵扣卡和折扣卡）
         const discountType = discount.tag || discount.type;
         const currentOriginUid = getOriginProductUid(originProduct);
         const isReapplyEditModeDiscountForProduct = discount.isEditMode && reapplyBookingDiscountProductUids.size > 0 && currentOriginUid && reapplyBookingDiscountProductUids.has(String(currentOriginUid)) && discount.isSelected === true;
@@ -939,7 +1103,7 @@ class RulesModule extends _BaseModule.BaseModule {
           if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
           if (!discount.isSelected) return false;
         }
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType) && !isReapplyEditModeDiscountForProduct) {
+        if (['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType ?? '') && !isReapplyEditModeDiscountForProduct) {
           // 如果策略检查后没有config，说明不可用
           if (discount.config === undefined || !discount?.config?.isAvailable) {
             return false;
@@ -947,17 +1111,22 @@ class RulesModule extends _BaseModule.BaseModule {
         }
 
         // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
-        // 商品券时主商品价格为0不可用
-        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.length && (discount.tag || discount.type) === 'good_pass') return false;
+        // 全额抵扣卡在主商品价格为 0 时不可用。
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.length && (0, _entitlementPass.isFullCoveragePass)(discount)) return false;
 
         // 折扣卡商品价格为0时不可用
-        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.find(n => n.discount?.resource_id === discount.id) && (discount.tag || discount.type) !== 'good_pass') return false;
-        // 如果优惠券已被使用，则跳过
-        const targetUsedDiscounts = usedDiscounts.get(discount.id);
-        if (targetUsedDiscounts && (discount.tag || discount.type) === 'good_pass') return false;
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.find(n => n.discount?.resource_id === discount.id) && !(0, _entitlementPass.isFullCoveragePass)(discount)) return false;
+        // good_pass 保持一张实例只使用一次。
+        if ((discount.tag || discount.type) === 'good_pass' && usedDiscounts.get(discount.id)) {
+          return false;
+        }
+        // 有限次数卡按后端实时 balance 约束本次新增分配；无限卡不看余额。
+        if ((0, _entitlementPass.isEntitlementPass)(discount) && (0, _entitlementPass.getRemainingEntitlementUses)(discount, entitlementUsageCounts.get(discount.id) || 0, 1) <= 0) {
+          return false;
+        }
 
         // 🔥 检查 maxUsagePerOrder 限制：同一 product_id 的商品券使用数量不能超过配置值
-        if ((discount.tag || discount.type) === 'good_pass') {
+        if ((0, _entitlementPass.isFullCoveragePass)(discount)) {
           const maxUsagePerOrder = discount.config?.maxUsagePerOrder;
           if (maxUsagePerOrder && maxUsagePerOrder > 0) {
             const currentUsedCount = usedProductIdCounts.get(discount.product_id) || 0;
@@ -973,7 +1142,7 @@ class RulesModule extends _BaseModule.BaseModule {
         const isHolderMatch = this.checkHolderMatch(discount, {
           isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
           holder_id: _tempVar?.holder_id || product.holder_id
-        }, holders);
+        }, flatItem.originProduct, holders);
         // 如果 holder 不匹配，则不适用
         if (!isHolderMatch) return false;
         let timeLimit = true;
@@ -1002,31 +1171,34 @@ class RulesModule extends _BaseModule.BaseModule {
         return false;
       });
 
-      // 用户显式点击某张卡券时，本次选择优先于自动排序和扫码默认选择。
+      // 识别用户本次显式选择的卡券，供次卡和折扣卡各自的优先级使用。
       // 目标仍必须在当前商品的 applicableDiscounts 中，因此不会绕过 Holder、时间或商品范围校验。
       const explicitlySelectedDiscount = options?.isSelected === true && options.discountId !== undefined ? applicableDiscounts.find(discount => {
         const discountType = discount.tag || discount.type;
-        return String(discount.id) === String(options.discountId) && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+        return String(discount.id) === String(options.discountId) && ['entitlement_pass', 'good_pass', 'discount_card', 'product_discount_card'].includes(discountType ?? '');
       }) : undefined;
       // 折扣卡会复用于整条商品行；商品券必须继续按单张拆分，不能复用该分支。
-      const explicitlySelectedDiscountCard = explicitlySelectedDiscount && (explicitlySelectedDiscount.tag || explicitlySelectedDiscount.type) !== 'good_pass' ? explicitlySelectedDiscount : undefined;
+      const explicitlySelectedDiscountCard = explicitlySelectedDiscount && !(0, _entitlementPass.isFullCoveragePass)(explicitlySelectedDiscount) ? explicitlySelectedDiscount : undefined;
 
-      // 商品数量等变化会触发无 discountId 的重算。只要当前行已应用的折扣卡仍在
+      // 商品数量等变化会触发无 discountId 的重算。只要当前行已应用的卡仍在
       // applicableDiscounts 中，就应保留该行选择，避免被自动排序中力度更大的卡替换。
-      const appliedDiscountCardIds = new Set((product.discount_list || []).filter(item => ['discount_card', 'product_discount_card'].includes(item?.tag || item?.type)).map(item => item?.discount?.resource_id ?? item?.resource_id ?? item?.id).filter(id => id !== undefined && id !== null).map(String));
+      const appliedWalletDiscountIds = new Set((product.discount_list || []).filter(item => ['entitlement_pass', 'discount_card', 'product_discount_card'].includes(item?.tag || item?.type)).map(item => item?.discount?.resource_id ?? item?.resource_id ?? item?.id).filter(id => id !== undefined && id !== null).map(String));
       const appliedDiscountCard = options?.scan ? undefined : applicableDiscounts.find(discount => {
         const discountType = discount.tag || discount.type;
-        return discount.isSelected === true && ['discount_card', 'product_discount_card'].includes(discountType) && appliedDiscountCardIds.has(String(discount.id));
+        return discount.isSelected === true && ['discount_card', 'product_discount_card'].includes(discountType ?? '') && appliedWalletDiscountIds.has(String(discount.id));
       });
+      const appliedEntitlementPass = options?.scan || options?.preserveEntitlementSelection === false ? undefined : applicableDiscounts.find(discount => (0, _entitlementPass.isEntitlementPass)(discount) && discount.isSelected === true && appliedWalletDiscountIds.has(String(discount.id)));
 
-      // 优先级：本次显式选择 > 当前行既有选择 > 扫码选择 > 自动排序第一项。
-      const scannedSelectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && (n.tag || n.type) !== 'good_pass');
+      // 次卡内部按本次手选/扫码、当前行已应用、默认排序选择。
+      const scannedSelectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && !(0, _entitlementPass.isFullCoveragePass)(n));
       const selectedDiscountCard = explicitlySelectedDiscountCard || appliedDiscountCard || scannedSelectedDiscountCard;
-      const selectedDiscount = explicitlySelectedDiscount || selectedDiscountCard || applicableDiscounts[0];
-      const prioritizedApplicableDiscounts = explicitlySelectedDiscount && (explicitlySelectedDiscount.tag || explicitlySelectedDiscount.type) === 'good_pass' ? [explicitlySelectedDiscount, ...applicableDiscounts.filter(discount => {
-        const discountType = discount.tag || discount.type;
-        return discountType === 'good_pass' && String(discount.id) !== String(explicitlySelectedDiscount.id);
-      }), ...applicableDiscounts.filter(discount => (discount.tag || discount.type) !== 'good_pass')] : applicableDiscounts;
+      const selectedEntitlementPass = (explicitlySelectedDiscount && (0, _entitlementPass.isEntitlementPass)(explicitlySelectedDiscount) ? explicitlySelectedDiscount : undefined) || applicableDiscounts.find(discount => (0, _entitlementPass.isEntitlementPass)(discount) && preferredEntitlementPassIds.has(String(discount.id))) || appliedEntitlementPass || applicableDiscounts.find(discount => (0, _entitlementPass.isEntitlementPass)(discount));
+      // 手选优先；普通重算保留当前折扣卡，扫码和最优选择仍使用原有优先级。
+      const selectedDiscount = explicitlySelectedDiscount || (options?.preserveEntitlementSelection !== false && preferredEntitlementPassIds.size === 0 ? appliedDiscountCard : undefined) || selectedEntitlementPass || selectedDiscountCard || applicableDiscounts[0];
+      // 实际次数分配必须使用同一顺序，避免选中状态切换后仍将次数分配给默认卡。
+      const prioritizedApplicableDiscounts = selectedDiscount && (0, _entitlementPass.isFullCoveragePass)(selectedDiscount) ? [selectedDiscount, ...applicableDiscounts.filter(discount => {
+        return (0, _entitlementPass.isFullCoveragePass)(discount) && String(discount.id) !== String(selectedDiscount.id);
+      }), ...applicableDiscounts.filter(discount => !(0, _entitlementPass.isFullCoveragePass)(discount))] : applicableDiscounts;
 
       // 如果是手动折扣，则不适用优惠券
       let isManualDiscount = false;
@@ -1142,19 +1314,13 @@ class RulesModule extends _BaseModule.BaseModule {
         return;
       }
 
-      // 是否需要拆分（商品券需要拆分）
-      const isNeedSplit = (selectedDiscount.tag || selectedDiscount.type) === 'good_pass';
+      // good_pass 与 Entitlement Pass 都沿用全额抵扣卡的商品行拆分机制。
+      const isNeedSplit = (0, _entitlementPass.isFullCoveragePass)(selectedDiscount);
 
       // 需要拆分出来的数量
       const totalQuantity = product.quantity || product.num || 1;
-      const availableGoodPassCount = applicableDiscounts.filter(item => (item.tag || item.type) === 'good_pass').length;
-
-      // 🔥 如果selectedDiscount有config配置，则使用config.maxUsagePerOrder限制使用次数
-      let maxUsageLimit = availableGoodPassCount;
-      if (selectedDiscount.config && selectedDiscount.config.maxUsagePerOrder) {
-        maxUsageLimit = Math.min(availableGoodPassCount, selectedDiscount.config.maxUsagePerOrder);
-      }
-      const splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, maxUsageLimit) : 1;
+      const fullCoveragePassUsageGroups = isNeedSplit ? buildFullCoveragePassUsageGroups(prioritizedApplicableDiscounts, totalQuantity) : [];
+      const splitCount = isNeedSplit ? fullCoveragePassUsageGroups.reduce((total, group) => total + group.count, 0) : 1;
       const arr = [];
 
       // 🔥 主商品和bundle子商品分别处理
@@ -1162,22 +1328,22 @@ class RulesModule extends _BaseModule.BaseModule {
         // 主商品：保持原有逻辑
         if (splitCount < totalQuantity && isNeedSplit) {
           const remainingQuantity = totalQuantity - splitCount;
-          const applicableNonGoodPassById = new Map(applicableDiscounts.filter(discount => (discount.tag || discount.type) !== 'good_pass').map(discount => [String(discount.id), discount]));
+          const applicableNonFullCoveragePassById = new Map(applicableDiscounts.filter(discount => !(0, _entitlementPass.isFullCoveragePass)(discount)).map(discount => [String(discount.id), discount]));
           const remainderDiscountList = (product.discount_list || []).filter(discount => {
             const discountType = discount.tag || discount.type;
             if (discountType === 'promotion') return true;
-            if (discountType === 'good_pass') return false;
+            if ((0, _entitlementPass.isFullCoveragePass)(discount)) return false;
             const resourceId = discount.discount?.resource_id ?? discount.id;
-            return resourceId !== undefined && resourceId !== null && applicableNonGoodPassById.has(String(resourceId));
+            return resourceId !== undefined && resourceId !== null && applicableNonFullCoveragePassById.has(String(resourceId));
           }).map(discount => {
             if ((discount.tag || discount.type) === 'promotion') return discount;
             const resourceId = discount.discount?.resource_id ?? discount.id;
-            const matchedDiscount = applicableNonGoodPassById.get(String(resourceId));
+            const matchedDiscount = applicableNonFullCoveragePassById.get(String(resourceId));
             if (matchedDiscount) {
               // 实际场景：3 件折扣卡商品中拆出 1 件改用商品券后，
               // 剩余 2 件仍在使用原折扣卡；必须同步登记折扣卡的使用状态，
               // 否则 updatedDiscountList 会把它改成未选中并清空 savedAmount。
-              usedDiscounts.set(matchedDiscount.id, true);
+              markDiscountUsed(matchedDiscount);
               const appliedProducts = appliedDiscountProducts.get(matchedDiscount.id) || [];
               appliedProducts.push({
                 ...discount,
@@ -1191,14 +1357,14 @@ class RulesModule extends _BaseModule.BaseModule {
               _num: remainingQuantity
             };
           });
-          const hasRetainedWalletDiscount = remainderDiscountList.some(discount => !['promotion', 'good_pass'].includes(discount.tag || discount.type));
+          const hasRetainedWalletDiscount = remainderDiscountList.some(discount => (discount.tag || discount.type) !== 'promotion' && !(0, _entitlementPass.isFullCoveragePass)(discount));
           let total = product.origin_total ?? product.total;
           if ((product.discount_list || []).some(item => item.type === 'promotion')) {
             total = product.total ?? product.origin_total;
           }
           arr.push(this.hooks.setProduct(originProduct, {
             // 商品券只替换被拆出的 splitCount 件。余量行原本仍有效的折扣卡
-            // 不能随 good_pass 拆分一起清除；已取消或已失效的折扣不会进入此列表。
+            // 不能随全额抵扣卡拆分一起清除；已取消或已失效的折扣不会进入此列表。
             discount_list: remainderDiscountList,
             quantity: remainingQuantity,
             _id: product._id.split('___')[0],
@@ -1210,14 +1376,21 @@ class RulesModule extends _BaseModule.BaseModule {
             } : {})
           }));
         }
-        for (let i = 0; i < splitCount; i++) {
-          const selectedDiscount = isNeedSplit ? prioritizedApplicableDiscounts[i] : selectedDiscountCard || applicableDiscounts[i];
+        const discountUsageGroups = isNeedSplit ? fullCoveragePassUsageGroups : [{
+          discount: selectedDiscount,
+          count: 1
+        }];
+        for (let i = 0; i < discountUsageGroups.length; i++) {
+          const {
+            discount: selectedDiscount,
+            count: appliedUseCount
+          } = discountUsageGroups[i];
           // 标记优惠券为已使用
-          usedDiscounts.set(selectedDiscount.id, true);
+          markDiscountUsed(selectedDiscount, appliedUseCount);
           // 🔥 更新 product_id 使用计数
-          if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+          if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
             const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
-            usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
+            usedProductIdCounts.set(selectedDiscount.product_id, currentCount + appliedUseCount);
           }
 
           // 记录实际应用了优惠券的商品信息
@@ -1279,7 +1452,7 @@ class RulesModule extends _BaseModule.BaseModule {
           const mainProductDiscountAmount = amount;
           const lineDiscountAmount = new _decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
           const discountType = selectedDiscount.tag || selectedDiscount.type;
-          const isGoodPass = discountType === 'good_pass';
+          const isFullCoverage = (0, _entitlementPass.isFullCoveragePass)(selectedDiscount);
           const discountDetail = {
             amount: lineDiscountAmount,
             type: selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : discountType,
@@ -1295,10 +1468,11 @@ class RulesModule extends _BaseModule.BaseModule {
               discount_product_id: selectedDiscount.product_id
             },
             // 前端使用的num数量，为了计算优惠金额
-            _num: isGoodPass ? 1 : product.num,
+            _num: isFullCoverage ? appliedUseCount : product.num,
             config: selectedDiscount?.config,
             metadata: {
-              num: 1,
+              encoded: selectedDiscount.metadata?.encoded || selectedDiscount.encoded,
+              num: isFullCoverage ? appliedUseCount : 1,
               discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
               // 🔥 order_level 分摊差值
               ...(productDiscountDifference !== undefined && {
@@ -1317,9 +1491,9 @@ class RulesModule extends _BaseModule.BaseModule {
           if (product.isClient) {
             arr.push(this.hooks.setProduct(originProduct, {
               discount_list: [discountDetail],
-              // good_pass：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
-              price: isGoodPass ? mainProductSellingPrice : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
+              // 全额抵扣卡：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
+              price: isFullCoverage ? mainProductSellingPrice : product.price,
+              quantity: isNeedSplit ? appliedUseCount : product.quantity,
               origin_total: (0, _utils2.getProductOriginTotalPrice)({
                 product: {
                   original_price: product.original_price
@@ -1336,8 +1510,8 @@ class RulesModule extends _BaseModule.BaseModule {
             arr.push(this.hooks.setProduct(originProduct, {
               discount_list: this.filterDiscountListByType(product.discount_list, 'promotion').concat([discountDetail]),
               _id: product._id.split('___')[0] + '___' + selectedDiscount.id + index,
-              price: selectedDiscount.tag === 'good_pass' ? 0 : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
+              price: isFullCoverage ? 0 : product.price,
+              quantity: isNeedSplit ? appliedUseCount : product.quantity,
               total: total,
               origin_total: productOriginTotal,
               main_product_selling_price: mainProductSellingPrice,
@@ -1354,14 +1528,17 @@ class RulesModule extends _BaseModule.BaseModule {
           const discountNum = splitCount;
           const normalNum = totalQuantity - discountNum;
 
-          // 生成有折扣的商品（每张商品券对应 num: 1）
-          for (let i = 0; i < discountNum; i++) {
-            const selectedDiscount = prioritizedApplicableDiscounts[i];
-            usedDiscounts.set(selectedDiscount.id, true);
+          // 同一卡实例的本次新增使用合并为一条，metadata.num 记录实际次数。
+          for (let i = 0; i < fullCoveragePassUsageGroups.length; i++) {
+            const {
+              discount: selectedDiscount,
+              count: appliedUseCount
+            } = fullCoveragePassUsageGroups[i];
+            markDiscountUsed(selectedDiscount, appliedUseCount);
             // 🔥 更新 product_id 使用计数
-            if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+            if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
               const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
-              usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
+              usedProductIdCounts.set(selectedDiscount.product_id, currentCount + appliedUseCount);
             }
 
             // 🔥 生成唯一的 _id
@@ -1369,11 +1546,12 @@ class RulesModule extends _BaseModule.BaseModule {
 
             // 计算折扣后的价格（使用 getDiscountAmount，内部已处理 maxDeductionAmount）
             const discountedPrice = (0, _utils.getDiscountAmount)(selectedDiscount, product.origin_total, product.origin_total);
-            const bundleDiscountAmount = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            const bundleDiscountAmountPerItem = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            const bundleDiscountAmount = new _decimal.default(bundleDiscountAmountPerItem).mul(appliedUseCount).toNumber();
             debugger;
             const discountDetail = {
               amount: bundleDiscountAmount,
-              type: 'good_pass',
+              type: selectedDiscount.tag || selectedDiscount.type,
               discount: {
                 fixed_amount: product.origin_total,
                 discount_calculation_mode: selectedDiscount?.metadata?.discount_calculation_mode,
@@ -1384,12 +1562,13 @@ class RulesModule extends _BaseModule.BaseModule {
                 discount_product_id: selectedDiscount.product_id
               },
               metadata: {
+                encoded: selectedDiscount.metadata?.encoded || selectedDiscount.encoded,
                 // 🔥 使用拆分后的唯一 _id
                 custom_product_bundle_map_id: uniqueId,
                 discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
-                num: 1
+                num: appliedUseCount
               },
-              _num: 1,
+              _num: appliedUseCount,
               config: selectedDiscount?.config
             };
 
@@ -1401,11 +1580,11 @@ class RulesModule extends _BaseModule.BaseModule {
               ...flatItem,
               // 🔥 使用唯一的 _id
               _id: uniqueId,
-              num: 1,
-              quantity: 1,
+              num: appliedUseCount,
+              quantity: appliedUseCount,
               price: discountedPrice,
               // 折扣后的价格
-              total: discountedPrice,
+              total: new _decimal.default(discountedPrice).mul(appliedUseCount).toNumber(),
               discount_list: [discountDetail],
               processed: true,
               _discountId: selectedDiscount.id
@@ -1427,9 +1606,9 @@ class RulesModule extends _BaseModule.BaseModule {
         } else {
           // 折扣卡：不拆分数量，直接应用
           const selectedDiscount = selectedDiscountCard || applicableDiscounts[0];
-          usedDiscounts.set(selectedDiscount.id, true);
+          markDiscountUsed(selectedDiscount);
           // 🔥 更新 product_id 使用计数（虽然此处主要是折扣卡，但保持一致性）
-          if ((selectedDiscount.tag || selectedDiscount.type) === 'good_pass') {
+          if ((0, _entitlementPass.isFullCoveragePass)(selectedDiscount)) {
             const currentCount = usedProductIdCounts.get(selectedDiscount.product_id) || 0;
             usedProductIdCounts.set(selectedDiscount.product_id, currentCount + 1);
           }
@@ -1479,6 +1658,7 @@ class RulesModule extends _BaseModule.BaseModule {
               discount_product_id: selectedDiscount.product_id
             },
             metadata: {
+              encoded: selectedDiscount.metadata?.encoded || selectedDiscount.encoded,
               // 🔥 使用唯一的 _id
               custom_product_bundle_map_id: uniqueId,
               discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
@@ -1562,11 +1742,10 @@ class RulesModule extends _BaseModule.BaseModule {
           // 没有bundle，直接使用主商品处理结果
           result.push(...mainProductArr);
         } else {
-          // 🔥 有bundle，需要检查子商品是否应用了商品券
+          // 🔥 有 bundle，需要检查子商品是否应用了全额抵扣卡
           // 1. 先收集所有bundle子商品的处理结果
           const bundleProcessingInfo = new Map();
-          let hasGoodPassApplied = false; // 标记是否有子商品应用了商品券
-
+          let hasFullCoveragePassApplied = false;
           if (product.bundle && Array.isArray(product.bundle)) {
             product.bundle.forEach((bundleItem, bundleIndex) => {
               const bundleItemId = `${product._id}_bundle_${bundleIndex}`;
@@ -1577,10 +1756,9 @@ class RulesModule extends _BaseModule.BaseModule {
               } else {
                 // 处理过的bundle item
                 bundleProcessingInfo.set(bundleIndex, processedBundleItems);
-                // 🔥 检查是否应用了商品券（good_pass）
-                const hasGoodPass = processedBundleItems.some(item => item.discount_list?.some(discount => discount.type === 'good_pass' || discount.tag === 'good_pass'));
-                if (hasGoodPass) {
-                  hasGoodPassApplied = true;
+                const hasFullCoveragePass = processedBundleItems.some(item => item.discount_list?.some(discount => (0, _entitlementPass.isFullCoveragePass)(discount)));
+                if (hasFullCoveragePass) {
+                  hasFullCoveragePassApplied = true;
                 }
               }
             });
@@ -1588,7 +1766,7 @@ class RulesModule extends _BaseModule.BaseModule {
 
           // 🔥 2. 如果有子商品应用了商品券，且主商品数量大于1，需要拆分主商品
           const mainProductQuantity = mainProductArr[0] ? this.hooks.getProduct(mainProductArr[0]).quantity : 1;
-          if (hasGoodPassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
+          if (hasFullCoveragePassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
             const mainProduct = mainProductArr[0];
             const mainProductData = this.hooks.getProduct(mainProduct);
 
@@ -1892,27 +2070,39 @@ class RulesModule extends _BaseModule.BaseModule {
 
       // 获取此优惠券实际应用的商品详情
       const appliedProductDetails = appliedDiscountProducts.get(discount.id) || [];
+      const committedAppliedProductDetails = (0, _entitlementPass.isEntitlementPass)(discount) ? mergeEntitlementAppliedProductDetails(discount.committedAppliedProductDetails || []) : [];
+      const allAppliedProductDetails = (0, _entitlementPass.isEntitlementPass)(discount) ? mergeEntitlementAppliedProductDetails([...committedAppliedProductDetails, ...appliedProductDetails]) : appliedProductDetails;
 
       // 根据是否有适用商品决定isAvailable
       const isAvailable = applicableProducts.length > 0;
+      const timeReasons = discountTimeReasons.get(discount.id) || [];
+      const timeReason = timeReasons.length ? timeReasons.every(Boolean) ? timeReasons[0] : undefined : (0, _utils.getDiscountTimeUnavailableReason)(discount, (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss'));
+      const reasonCode = isAvailable ? undefined : (0, _availability.getDiscountUsageBlockReason)(discount) || timeReason || discount.reasonCode || (discountHolderMismatch.has(discount.id) ? 'holder_not_matched' : 'product_not_applicable');
+      const availabilityReason = {
+        reasonCode,
+        reason: reasonCode && reasonCode === discount.reasonCode ? discount.reason : undefined
+      };
 
       // 如果此优惠券被明确设置为不选中，保持其状态，但正确设置isAvailable
       if (typeof discount.isSelected === 'boolean' && discount.isSelected === false && discount.isManualSelect) {
         return {
           ...discount,
+          ...availabilityReason,
           isSelected: false,
           isAvailable: isAvailable,
           // 正确设置可用性
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
           applicableProductDetails: applicableProductDetails,
-          // 添加实际抵扣的商品详情（对于未选中的优惠券，为空数组）
-          appliedProductDetails: []
+          // 已提交的历史使用不可撤销；只取消本次新增分配。
+          appliedProductDetails: committedAppliedProductDetails
         };
       }
-      if (usedDiscounts.get(discount.id)) {
+      if (isDiscountUsed(discount)) {
         return {
           ...discount,
+          reason: undefined,
+          reasonCode: undefined,
           isSelected: true,
           isManualSelect: options?.scan ? false : discount.isManualSelect,
           // 标记为可用，因为它已被应用
@@ -1922,7 +2112,7 @@ class RulesModule extends _BaseModule.BaseModule {
           // 添加可抵扣的商品详情
           applicableProductDetails: applicableProductDetails,
           // 添加实际抵扣的商品详情
-          appliedProductDetails: appliedProductDetails
+          appliedProductDetails: allAppliedProductDetails
         };
       }
       let isSelected = typeof discount.isSelected === 'boolean' ? discount.isSelected : undefined;
@@ -1930,11 +2120,12 @@ class RulesModule extends _BaseModule.BaseModule {
       // 如果是可用的 并且没有手动标记 则设置为选中
       if (isAvailable && appliedProductDetails.length && !discount.isManualSelect) {
         isSelected = true;
-      } else if (!appliedProductDetails.length) {
+      } else if (!appliedProductDetails.length && !committedAppliedProductDetails.length) {
         isSelected = false;
       }
       return {
         ...discount,
+        ...availabilityReason,
         // 如果有适用的商品，标记为可用
         isAvailable: isAvailable,
         isSelected,
@@ -1944,13 +2135,69 @@ class RulesModule extends _BaseModule.BaseModule {
         applicableProductIds: applicableProducts,
         // 添加可抵扣的商品详情
         applicableProductDetails: applicableProductDetails,
-        // 添加实际抵扣的商品详情（对于未使用的优惠券，为空数组）
-        appliedProductDetails: []
+        // 编辑订单的历史使用继续保留，本次没有新增使用。
+        appliedProductDetails: committedAppliedProductDetails
+      };
+    });
+
+    // 整单分配完成后统一记录卡余额；历史使用已包含在服务端余额中，只扣本次新增次数。
+    const entitlementBalances = new Map();
+    addModeDiscount.forEach(discount => {
+      const quota = (0, _entitlementPass.resolveEntitlementQuota)(discount);
+      if (!quota) return;
+      entitlementBalances.set(String(discount.id), quota.type === 'unlimited' ? null : Math.max(quota.balance - (entitlementUsageCounts.get(discount.id) || 0), 0));
+    });
+    const getEntitlementBalance = detail => {
+      if (!(0, _entitlementPass.isEntitlementPass)(detail)) return undefined;
+      const resourceId = detail?.discount?.resource_id ?? detail?.resource_id;
+      return entitlementBalances.get(String(resourceId));
+    };
+    const needsEntitlementBalance = detail => {
+      const balance = getEntitlementBalance(detail);
+      return balance !== undefined && detail?.metadata?.balance !== balance;
+    };
+    const withEntitlementBalance = detail => {
+      if (!needsEntitlementBalance(detail)) return detail;
+      return {
+        ...detail,
+        metadata: {
+          ...(detail.metadata || {}),
+          balance: getEntitlementBalance(detail)
+        }
+      };
+    };
+    const getProductDiscountDetails = originProduct => {
+      const product = this.hooks.getProduct(originProduct);
+      return [...(product.discount_list || []), ...(product.bundle || []).flatMap(bundle => bundle.discount_list || [])];
+    };
+    const productsWithEntitlementBalances = entitlementBalances.size ? processedProductList.map(product => {
+      if (!getProductDiscountDetails(product).some(needsEntitlementBalance)) {
+        return product;
+      }
+      // 历史商品及套餐可能仍引用输入快照；仅复制有变化的行，并直接更新 metadata。
+      // 不再次调用价格换算钩子，避免只补余额时改变商品价格。
+      const nextProduct = (0, _lodashEs.cloneDeep)(product);
+      getProductDiscountDetails(nextProduct).forEach(detail => {
+        if (!needsEntitlementBalance(detail)) return;
+        detail.metadata = withEntitlementBalance(detail).metadata;
+      });
+      return nextProduct;
+    }) : processedProductList;
+    const discountsWithEntitlementBalances = [...editModeDiscount, ...updatedDiscountList].map(discount => {
+      if (!(0, _entitlementPass.isEntitlementPass)(discount) || !entitlementBalances.has(String(discount.id))) {
+        return discount;
+      }
+      return {
+        ...discount,
+        appliedProductDetails: (discount.appliedProductDetails || []).map(withEntitlementBalance),
+        ...(discount.committedAppliedProductDetails ? {
+          committedAppliedProductDetails: discount.committedAppliedProductDetails.map(withEntitlementBalance)
+        } : {})
       };
     });
     return {
-      productList: processedProductList,
-      discountList: [...editModeDiscount, ...updatedDiscountList]
+      productList: productsWithEntitlementBalances,
+      discountList: discountsWithEntitlementBalances
     };
   }