@pisell/pisellos 2.3.143 → 2.3.145

package/dist/solution/UnifiedBookingSales/types.d.ts

@@ -72,6 +72,11 @@ export interface UnifiedBookingSalesPrepareAvailabilityProjectionParams {
 }
 export interface AvailabilityContextRef {
     contextId: string;
+    /** POS/Kiosk duration protocol capability and business-day default. */
+    durationTimeSelection?: {
+        version: 1;
+        currentBusinessDate: string;
+    };
 }
 export interface ContextualProductTimeRange extends ProductTimeRange {
     availabilityContextId: string;
@@ -80,7 +85,7 @@ export interface ContextualProductTimeRange extends ProductTimeRange {
 export interface ContextualProductTimeRangeGroup extends Omit<ProductTimeRangeGroup, 'ranges'> {
     ranges: ContextualProductTimeRange[];
 }
-export type ContextualAvailabilityQuery = Omit<Extract<AvailabilityQuery, {
+export type ContextualAvailabilityQuery = (Omit<Extract<AvailabilityQuery, {
     target: 'product';
 }>, never> | Omit<Extract<AvailabilityQuery, {
     target: 'date';
@@ -92,7 +97,10 @@ export type ContextualAvailabilityQuery = Omit<Extract<AvailabilityQuery, {
     target: 'resource';
 }>, 'selectedRanges'> & {
     selectedRanges: ContextualProductTimeRange[];
-});
+})) & {
+    /** Automatic remembered selection must not inherit POS manual exceptions. */
+    selectionIntent?: 'remembered' | 'manual';
+};
 export type ContextualTimeAvailabilityItem = Omit<TimeAvailabilityItem, keyof ProductTimeRange> & ContextualProductTimeRange;
 export interface ContextualTimeAvailabilityGroup extends Omit<TimeAvailabilityGroup, 'times'> {
     times: ContextualTimeAvailabilityItem[];
@@ -155,6 +163,10 @@ export interface UnifiedBookingSalesAddRetailProductParams {
 }
 export interface ContextualCommitAvailabilitySelectionParams {
     mode: 'add' | 'edit';
+    /** Only POS duration add supports automatic remembered-time commits. */
+    selectionIntent?: 'remembered' | 'manual';
+    /** Local UI intent guard, checked again immediately before the Order mutation. */
+    availabilityCommitGuard?: () => void;
     productLineUid?: string;
     orderProduct: Record<string, any>;
     candidate: ContextualProductTimeRange;

package/lib/modules/BookingContext/utils/productExtend.d.ts

@@ -7,6 +7,13 @@ import { TimeSlicesResult, TimeSlice, DurationSlice } from './timeSlices';
  * 让 OS 这层完全可在 Node 单测下运行（dayjs 在 Node 也是纯函数）。
  */
 export interface BookingCalcContext {
+    /** Sales channel; remembered duration starts are accepted only by POS. */
+    channel?: string;
+    /** Start-only device preference for this decision; never reuse a cached end/resource. */
+    rememberedTime?: {
+        businessDate: string;
+        startAt: string;
+    };
     /** 来自 `/core/board/management/config` 的整套配置；常用路径见 sliceTimeSlices / appointmentTimingPreference。 */
     bookingConfig?: any;
     /** 资源 origin map（id → resource origin）。 */

package/lib/modules/BookingContext/utils/productExtend.js

@@ -28,6 +28,44 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 让 OS 这层完全可在 Node 单测下运行（dayjs 在 Node 也是纯函数）。
  */
 
+/** Rebuild only the derived booking fields; SKU, quantity, notes and Holder stay intact. */
+function seedRememberedBookingStart(cacheItem, ctx) {
+  const remembered = ctx.rememberedTime;
+  const invalid = () => Object.assign(new Error('Remembered time requires a valid POS duration start.'), {
+    code: 'INVALID_REMEMBERED_TIME'
+  });
+  const duration = cacheItem?.duration;
+  const durationType = typeof duration === 'object' && duration ? String(duration.type || '').toLowerCase() : '';
+  const durationValue = typeof duration === 'object' && duration ? duration.value : duration;
+  const isDuration = (0, _flexible.isProductFlexibleDuration)(duration) || ['', 'fixed', 'minute', 'minutes', 'hour', 'hours'].includes(durationType) && Number.isFinite(Number(durationValue)) && Number(durationValue) > 0;
+  const isCalendarDate = value => {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+  };
+  const parts = typeof remembered?.startAt === 'string' ? /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,3})?)?(?:Z|[+-](\d{2}):(\d{2}))?$/.exec(remembered.startAt) : null;
+  if (String(ctx.channel || '').trim().toLowerCase() !== 'pos' || !isDuration || (0, _serviceTimes.isMultiDayProduct)(cacheItem) || (0, _serviceTimes.isSessionProduct)(cacheItem) || cacheItem?.cartDetailValue?.session || cacheItem?._extend?.other?.session || !isCalendarDate(remembered?.businessDate) || !parts || !isCalendarDate(parts[1]) || Number(parts[2]) > 23 || Number(parts[3]) > 59 || Number(parts[4] || 0) > 59 || Number(parts[5] || 0) > 23 || Number(parts[6] || 0) > 59) throw invalid();
+  // Parse the actual instant with the same runtime clock used by the legacy booking helpers.
+  // The business-day label must not replace the calendar date of an overnight start.
+  const start = (0, _dayjs.default)(remembered.startAt);
+  if (!start.isValid()) throw invalid();
+  const extend = {
+    ...(cacheItem?._extend || {})
+  };
+  for (const key of ['start_date', 'startDate', 'start_time', 'end_date', 'endDate', 'end_time', 'duration', 'resource', 'resources', 'capacity', 'booking', 'availabilitySelection']) delete extend[key];
+  return {
+    ...cacheItem,
+    new: 1,
+    autoClose: false,
+    _data: {},
+    _extend: {
+      ...extend,
+      start_date: start.format('YYYY-MM-DD'),
+      start_time: start.format(start.millisecond() ? 'HH:mm:ss.SSS' : start.second() ? 'HH:mm:ss' : 'HH:mm')
+    }
+  };
+}
+
 /** 从 BookingContext.date 提取 HH:mm（仅当日期带有效时分时）。 */
 function derivePresetStartTimeFromDate(date) {
   if (date == null) return undefined;
@@ -195,10 +233,15 @@ function getServiceStartTimeAndEndTime(params) {
  */
 function getProductExtend(params) {
   const {
-    cacheItem,
-    ctx,
     isDisabledTime
   } = params;
+  const hasRememberedTime = params.ctx.rememberedTime !== undefined;
+  const cacheItem = hasRememberedTime ? seedRememberedBookingStart(params.cacheItem, params.ctx) : params.cacheItem;
+  const ctx = hasRememberedTime ? {
+    ...params.ctx,
+    previousService: undefined,
+    presetStartTime: undefined
+  } : params.ctx;
   const isNew = cacheItem.new || !cacheItem._extend?.endDate;
   const _cacheItem = {
     ...cacheItem

package/lib/modules/Order/index.d.ts

@@ -332,6 +332,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     private applyOrderProductsDepositSummary;
     recalculateSummary(options?: {
         createIfMissing?: boolean;
+        isCurrentOrder?: () => boolean;
     }): Promise<OrderSummary | null>;
     getOrderSummary(): Promise<OrderSummary>;
     updateTempOrderNote(note: string): string;
@@ -592,7 +593,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     generateIdempotencyToken(): string;
     syncPaymentsToOrder<T = any>(params: SyncPaymentsToOrderParams): Promise<SyncPaymentsToOrderResult<T>>;
     createOrder(params: CommitOrderParams['query']): {
-        type: "virtual" | "appointment_booking";
+        type: "appointment_booking" | "virtual";
         platform: string;
         sales_channel: string;
         order_sales_channel: string;

package/lib/modules/Order/index.js

@@ -913,7 +913,8 @@ class OrderModule extends _BaseModule.BaseModule {
    * - 不主动调用 applyDiscount / recalculateSummary，调用方负责跟进；
    * - 返回的 payload 只能在 applyDiscount（商品写路径还需 summary/persist）完成后发布。
    */
-  async evaluatePromotion() {
+  async evaluatePromotion(options) {
+    if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
     if (this.isApplyingPromotion || this.isEmittingPromotionApplied) {
       return null;
     }
@@ -974,6 +975,10 @@ class OrderModule extends _BaseModule.BaseModule {
                 continue;
               }
             }
+            const giftMutationBaseline = options?.isCurrentOrder ? (0, _lodashEs.cloneDeep)({
+              products: tempOrder.products,
+              bookings: tempOrder.bookings
+            }) : null;
             try {
               const giftResult = await this.giftSelectResolver({
                 strategyId: addAction.strategyId,
@@ -982,6 +987,11 @@ class OrderModule extends _BaseModule.BaseModule {
                 giftOptions: addAction.giftOptions,
                 sourceProductIds: addAction.sourceProductIds
               });
+              if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
+              if (options?.isCurrentOrder && !(0, _lodashEs.isEqual)({
+                products: tempOrder.products,
+                bookings: tempOrder.bookings
+              }, giftMutationBaseline)) return null;
               const giftProducts = Array.isArray(giftResult) ? giftResult : giftResult?.products;
               const giftBookings = Array.isArray(giftResult) ? [] : giftResult?.bookings || [];
               if (Array.isArray(giftProducts) && giftProducts.length > 0) {
@@ -1002,12 +1012,18 @@ class OrderModule extends _BaseModule.BaseModule {
                 }
               }
             } catch (error) {
+              if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
+              if (options?.isCurrentOrder && !(0, _lodashEs.isEqual)({
+                products: tempOrder.products,
+                bookings: tempOrder.bookings
+              }, giftMutationBaseline)) return null;
               // 用户取消 / 选择失败 → 视为放弃本次新增
               console.warn('[OrderModule] giftSelectResolver rejected, skip add gift', addAction.strategyId, error);
             }
           }
         }
       }
+      if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
       tempOrder.products = result.products;
       this.lastUnfulfilledPromotions = result.unfulfilledPromotions;
       this.lastGiftActions = result.giftActions;
@@ -2469,6 +2485,7 @@ class OrderModule extends _BaseModule.BaseModule {
     return shouldUseManualDepositOverride ? nextSummary : this.applyLastOrderDepositSnapshot(tempOrder, nextSummary);
   }
   async recalculateSummary(options) {
+    if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
     const tempOrder = options?.createIfMissing ? this.ensureTempOrder() : this.store.tempOrder;
     if (!tempOrder) return null;
     this.sanitizeTempOrderProducts(tempOrder);
@@ -2478,7 +2495,7 @@ class OrderModule extends _BaseModule.BaseModule {
     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;
+    const summaryProducts = shouldFullRecalculateFromSnapshot || options?.isCurrentOrder ? (0, _lodashEs.cloneDeep)(tempOrder.products || []) : tempOrder.products;
     if (shouldFullRecalculateFromSnapshot) {
       this.clearPersistedAmountFieldsForFullRecalc(summaryProducts || []);
     }
@@ -2516,6 +2533,10 @@ class OrderModule extends _BaseModule.BaseModule {
       });
       return this.store.summary;
     }
+    const summaryMutationBaseline = options?.isCurrentOrder ? (0, _lodashEs.cloneDeep)({
+      tempOrder,
+      summary: this.store.summary
+    }) : null;
     const salesSummaryResult = await salesSummary.getSummary({
       products: summaryProducts,
       isPriceIncludeTax: tempOrder.is_price_include_tax,
@@ -2525,7 +2546,12 @@ class OrderModule extends _BaseModule.BaseModule {
         channel: this.otherParams.channel
       } : {})
     });
-    if (shouldFullRecalculateFromSnapshot) {
+    if (options?.isCurrentOrder && !options.isCurrentOrder()) return null;
+    if (options?.isCurrentOrder && !(0, _lodashEs.isEqual)({
+      tempOrder,
+      summary: this.store.summary
+    }, summaryMutationBaseline)) return null;
+    if (shouldFullRecalculateFromSnapshot || options?.isCurrentOrder) {
       tempOrder.products = summaryProducts;
     }
     this.syncSummaryProductMetadata(tempOrder.products || []);
@@ -3454,20 +3480,30 @@ class OrderModule extends _BaseModule.BaseModule {
    * await this.finalizeProductOrderMutation(tempOrder);
    */
   async finalizeProductOrderMutation(tempOrder, options) {
+    const isCurrentOrder = options?.isCurrentOrder;
+    if (isCurrentOrder && !isCurrentOrder()) return;
     this.syncTempOrderHolderFromBookings(tempOrder);
     this.prepareVirtualSettlementTempOrder(tempOrder);
     const isVirtualSettlement = this.isActiveVirtualSettlementOrder(tempOrder);
     if (!options?.skipEditDiscountConfigRefresh && !isVirtualSettlement) {
       await this.ensureEditDiscountConfigForProductChange(tempOrder);
     }
-    const promotionPayload = !options?.skipDiscountRecalculation && !isVirtualSettlement ? await this.evaluatePromotion() : null;
+    if (isCurrentOrder && !isCurrentOrder()) return;
+    const promotionPayload = !options?.skipDiscountRecalculation && !isVirtualSettlement ? await this.evaluatePromotion(isCurrentOrder ? {
+      isCurrentOrder
+    } : undefined) : null;
+    if (isCurrentOrder && !isCurrentOrder()) return;
     if (!options?.skipDiscountRecalculation && !isVirtualSettlement) {
       this.applyDiscount();
     }
     this.sanitizeTempOrderProducts(tempOrder);
-    await this.recalculateSummary({
-      createIfMissing: true
+    const summary = await this.recalculateSummary({
+      createIfMissing: true,
+      ...(isCurrentOrder ? {
+        isCurrentOrder
+      } : {})
     });
+    if (isCurrentOrder && (!isCurrentOrder() || !summary)) return;
     this.persistTempOrder();
     this.emitPromotionApplied(promotionPayload);
   }
@@ -3704,8 +3740,16 @@ class OrderModule extends _BaseModule.BaseModule {
    * // → tempOrder.products 新增 3 行，每行 num=1，bookings 3 条
    */
   async addProductToOrder(product, booking, options) {
-    const tempOrder = this.ensureTempOrder();
-    const beforeCommit = this.createCartIntentCommitGuard('add_product', tempOrder);
+    const availabilityCommitGuard = options?.availabilityCommitGuard;
+    availabilityCommitGuard?.();
+    const liveTempOrder = this.ensureTempOrder();
+    const beforeCommit = this.createCartIntentCommitGuard('add_product', liveTempOrder);
+    // 自动预约在草稿上准备完整批次，避免拆票期间暴露半成品，或在失败时
+    // 用整单快照回滚而抹掉其他入口的并发修改。人工路径保持原有写入行为。
+    const tempOrder = availabilityCommitGuard ? (0, _lodashEs.cloneDeep)(liveTempOrder) : liveTempOrder;
+    const guardedMutationFields = ['products', 'bookings', 'notes', '_extend', 'metadata', 'currency_code', 'currency_symbol', 'currency_format'];
+    const readGuardedMutationFields = order => Object.fromEntries(guardedMutationFields.map(key => [key, order[key]]));
+    const guardedMutationBaseline = availabilityCommitGuard ? (0, _lodashEs.cloneDeep)(readGuardedMutationFields(liveTempOrder)) : null;
     const salesNoteDrafts = (options?.salesNotes || []).map(draft => ({
       note_type: String(draft.note_type || '').trim(),
       text: {
@@ -3779,6 +3823,7 @@ class OrderModule extends _BaseModule.BaseModule {
               disableMerge: options?.disableMerge,
               beforeCommit
             });
+            availabilityCommitGuard?.();
             attachSalesNoteDrafts(committedProduct);
             if (insertAtIndex !== undefined) insertAtIndex += 1;
           }
@@ -3788,6 +3833,7 @@ class OrderModule extends _BaseModule.BaseModule {
             disableMerge: options?.disableMerge,
             beforeCommit
           });
+          availabilityCommitGuard?.();
           attachSalesNoteDrafts(committedProduct);
         }
       } else {
@@ -3796,18 +3842,54 @@ class OrderModule extends _BaseModule.BaseModule {
           disableMerge: options?.disableMerge,
           beforeCommit
         });
+        availabilityCommitGuard?.();
         attachSalesNoteDrafts(committedProduct);
       }
+      if (availabilityCommitGuard) {
+        availabilityCommitGuard();
+        beforeCommit();
+        // 调用方的结构 revision 可能不包括备注、价格或结算元数据。
+        // 本次会覆盖的字段也要保持原值，不能让草稿覆盖并发编辑。
+        if (!(0, _lodashEs.isEqual)(readGuardedMutationFields(liveTempOrder), guardedMutationBaseline)) {
+          throw Object.assign(new Error('预约加购期间订单已变化，请重新选择'), {
+            code: 'AVAILABILITY_SELECTION_STALE'
+          });
+        }
+        // 从最后一次门禁到真正新增之间不再 await。只发布本次新增会改写的
+        // 字段；其余订单字段继续使用 live 对象，外部持有的订单引用也不变。
+        Object.assign(liveTempOrder, readGuardedMutationFields(tempOrder));
+      }
     } catch (error) {
       rollbackProductAndNotesMutation();
       throw error;
     }
-    await this.finalizeProductOrderMutation(tempOrder);
+    // 发布后预约已加购；后续促销/summary 沿用既有收尾，不用自身新增后的
+    // revision 再执行提交 CAS，也不会把已加购预约因收尾耗时而撤回。
+    if (availabilityCommitGuard) {
+      const committedIdentity = [liveTempOrder.order_id, liveTempOrder.external_sale_number];
+      const isCurrentOrder = () => this.store.tempOrder === liveTempOrder && liveTempOrder.order_id === committedIdentity[0] && liveTempOrder.external_sale_number === committedIdentity[1] && (options?.availabilityCommitTargetGuard?.() ?? true);
+      try {
+        // 新增已发布，即使后续报价/促销收尾失败，也不能向调用方报告未加购。
+        // 先保存已提交行；异步结果只允许写回仍属于本次提交的订单。
+        if (isCurrentOrder()) this.persistTempOrder();
+        await this.finalizeProductOrderMutation(liveTempOrder, {
+          isCurrentOrder
+        });
+      } catch (error) {
+        this.logWarning('addProductToOrder committed; finalization failed', {
+          product_id: product.product_id,
+          committed: true,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } else {
+      await this.finalizeProductOrderMutation(liveTempOrder);
+    }
     this.logInfo('addProductToOrder success', {
       product_id: product.product_id,
       with_booking: !!booking
     });
-    return tempOrder.products;
+    return liveTempOrder.products;
   }
 
   /**

package/lib/modules/Order/types.d.ts

@@ -445,6 +445,15 @@ export interface AddProductToOrderOptions {
     disableMerge?: boolean;
     /** 商品行 UID 落定后，由 OrderModule 原子绑定到该行的 Sales Notes 草稿。 */
     salesNotes?: SalesNoteDraftInput[];
+    /**
+     * 自动预约加购的同步提交门禁；抛错时不发布本次新增。
+     * 带门禁时先在私有草稿中准备全部商品/booking，异步等待后及原子发布前重新调用。
+     * 门禁须校验当前订单身份/版本和真实时间；发布前不会因本次拆行改变订单版本。
+     * 不传时保留原有人工加购行为。
+     */
+    availabilityCommitGuard?: () => void;
+    /** 发布后的订单/业务归属检查；只用于阻止旧异步收尾写入新单，不再校验截止或 revision。 */
+    availabilityCommitTargetGuard?: () => boolean;
 }
 /**
  * 删除商品后的可选位置保持策略。

package/lib/modules/Order/utils.d.ts

@@ -121,8 +121,9 @@ export declare function getBundleSellingMagnitude(bundle: Record<string, any> |
  *   = `metadata.main_product_original_price` + Σ(bundle 原价 × num)。
  * - `metadata.source_product_price`：主商品/variant 基础价（已应用报价单），不含 option、
  *   不含折扣。**权威源**。
- * - `metadata.main_product_original_price` = source + Σ(option.price × option.num)（含 option、不含折扣）。
- * - `metadata.main_product_selling_price` = main_original − 主商品券 per-unit amount（含 option、含折扣）。
+ * - `product_sku.option[].add_price` 保留单规格折前单价；Rules 的 option.price 只用于本次计算。
+ * - `metadata.main_product_original_price` = source + Σ(option.add_price × option.num)（含 option、不含折扣）。
+ * - `metadata.main_product_selling_price` = main_original − 行内 per-unit amount（含主商品及 option 优惠）。
  * - `payment_price`：出站 payload 中为行 composite 已减整单折扣均摊价（无折扣时与 `selling_price` 同义）。
  *
  * Rules 钩子契约（hook_adapt 方案，Rules 内部保持不变）：
@@ -131,8 +132,9 @@ export declare function getBundleSellingMagnitude(bundle: Record<string, any> |
  *   `getProductOriginTotalPrice` 会自行叠加 option + bundle，喂 source 可避免 option 双加。
  * - `getProduct.total` = `selling_price × num`（行 composite × num），与 Rules 内部产出的
  *   total（source + option + bundle）对齐。
+ * - `getProduct.options` 用单规格原价参与重算；主商品折后价从 main_selling 减去 option 折后合计反推。
  * - `setProduct` 反向流程：把 Rules 返回的 source-level `main_product_selling_price` / `price`
- *   加回 Σoptions，重新合成含 option 的 main_product_* 并派生 composite。
+ *   加回单规格原价合计，再减去 optionDiscountAmount；保留订单单规格原价供取消折扣及后续重算。
  *   优先级：
  *     1. `values.main_product_selling_price`（券应用分支，per-unit 券后 source-level 主价）
  *     2. `values.price`（还原分支 `restoredPrice`、good_pass 归零）

package/lib/modules/Order/utils.js

@@ -641,8 +641,9 @@ function getBundleSellingMagnitude(bundle) {
  *   = `metadata.main_product_original_price` + Σ(bundle 原价 × num)。
  * - `metadata.source_product_price`：主商品/variant 基础价（已应用报价单），不含 option、
  *   不含折扣。**权威源**。
- * - `metadata.main_product_original_price` = source + Σ(option.price × option.num)（含 option、不含折扣）。
- * - `metadata.main_product_selling_price` = main_original − 主商品券 per-unit amount（含 option、含折扣）。
+ * - `product_sku.option[].add_price` 保留单规格折前单价；Rules 的 option.price 只用于本次计算。
+ * - `metadata.main_product_original_price` = source + Σ(option.add_price × option.num)（含 option、不含折扣）。
+ * - `metadata.main_product_selling_price` = main_original − 行内 per-unit amount（含主商品及 option 优惠）。
  * - `payment_price`：出站 payload 中为行 composite 已减整单折扣均摊价（无折扣时与 `selling_price` 同义）。
  *
  * Rules 钩子契约（hook_adapt 方案，Rules 内部保持不变）：
@@ -651,8 +652,9 @@ function getBundleSellingMagnitude(bundle) {
  *   `getProductOriginTotalPrice` 会自行叠加 option + bundle，喂 source 可避免 option 双加。
  * - `getProduct.total` = `selling_price × num`（行 composite × num），与 Rules 内部产出的
  *   total（source + option + bundle）对齐。
+ * - `getProduct.options` 用单规格原价参与重算；主商品折后价从 main_selling 减去 option 折后合计反推。
  * - `setProduct` 反向流程：把 Rules 返回的 source-level `main_product_selling_price` / `price`
- *   加回 Σoptions，重新合成含 option 的 main_product_* 并派生 composite。
+ *   加回单规格原价合计，再减去 optionDiscountAmount；保留订单单规格原价供取消折扣及后续重算。
  *   优先级：
  *     1. `values.main_product_selling_price`（券应用分支，per-unit 券后 source-level 主价）
  *     2. `values.price`（还原分支 `restoredPrice`、good_pass 归零）
@@ -851,6 +853,14 @@ function createDefaultOrderRulesHooks(getBookings) {
     const effectiveNum = Number(num) > 0 ? Number(num) : 1;
     return new _decimal.default(Number(totalLike) || 0).dividedBy(effectiveNum).toDecimalPlaces(2).toString();
   };
+
+  // optionDiscountAmount 已是每件主商品内的单规格优惠合计，不再乘商品数量。
+  const getOptionDiscountAmount = discountList => {
+    return (discountList || []).reduce((total, discount) => {
+      if (discount?.metadata?.custom_product_bundle_map_id) return total;
+      return total.plus(Number(discount?.metadata?.optionDiscountAmount) || 0);
+    }, new _decimal.default(0));
+  };
   const getBundleIdentity = bundle => {
     return [bundle.bundle_id ?? bundle.id ?? '', bundle.bundle_product_id ?? bundle._bundle_product_id ?? bundle.product_id ?? '', bundle.bundle_variant_id ?? bundle.variant_id ?? bundle.product_variant_id ?? 0, bundle.bundle_group_id ?? bundle.group_id ?? ''].join('|');
   };
@@ -893,12 +903,14 @@ function createDefaultOrderRulesHooks(getBookings) {
     getProduct: product => {
       // source_product_price 是权威源；兜底链：source → mainSelling − options（反推）→ 行 selling_price
       const metadataAny = product.metadata || {};
-      const optionSum = sumOptionUnitPrice(getProductSkuOptions(product));
+      const productOptions = getProductSkuOptions(product);
+      const optionSum = sumOptionUnitPrice(productOptions);
+      const optionSellingSum = optionSum.minus(getOptionDiscountAmount(product.discount_list));
       let sourcePrice;
       if (metadataAny.source_product_price !== undefined) {
         sourcePrice = String(metadataAny.source_product_price);
       } else if (metadataAny.main_product_selling_price !== undefined) {
-        sourcePrice = new _decimal.default(Number(metadataAny.main_product_selling_price) || 0).minus(optionSum).toDecimalPlaces(2).toString();
+        sourcePrice = new _decimal.default(Number(metadataAny.main_product_selling_price) || 0).minus(optionSellingSum).toDecimalPlaces(2).toString();
       } else {
         sourcePrice = String(product.selling_price ?? 0);
       }
@@ -928,6 +940,11 @@ function createDefaultOrderRulesHooks(getBookings) {
         num: product.num || 1,
         discount_list: product.discount_list || [],
         bundle: product.product_bundle || [],
+        // 仅在 Rules 入参中映射 price，避免折后价污染订单的 add_price。
+        options: productOptions.map(option => ({
+          ...option,
+          price: option.add_price
+        })),
         booking_id: product.metadata?.booking_id || null,
         isClient: false,
         // 勿写死 false：否则 Rules 不会走 total≠origin_total 的手动价推断，
@@ -935,7 +952,7 @@ function createDefaultOrderRulesHooks(getBookings) {
         isManualDiscount: resolveRulesManualDiscountFlag(metadataAny),
         holder_id: product.metadata?.holder_id,
         startDate: getProductStartDate(product),
-        main_product_selling_price: metadataAny.main_product_selling_price !== undefined ? new _decimal.default(Number(metadataAny.main_product_selling_price) || 0).minus(optionSum).toDecimalPlaces(2).toString() : undefined,
+        main_product_selling_price: metadataAny.main_product_selling_price !== undefined ? new _decimal.default(Number(metadataAny.main_product_selling_price) || 0).minus(optionSellingSum).toDecimalPlaces(2).toString() : undefined,
         inPromotion: metadataAny._promotion?.inPromotion === true,
         _promotion: metadataAny._promotion
       };
@@ -946,8 +963,10 @@ function createDefaultOrderRulesHooks(getBookings) {
       const existedSource = metadataAny.source_product_price ?? product.selling_price ?? '0';
       const nextOptions = getProductSkuOptions(product);
       const optionSum = sumOptionUnitPrice(nextOptions);
+      const nextDiscountList = values.discount_list ?? product.discount_list;
+      const optionSellingSum = optionSum.minus(getOptionDiscountAmount(nextDiscountList));
 
-      // Rules 返回的 main_product_selling_price / price / total 均为 source-level。
+      // Rules 返回的 main_product_selling_price / price 为不含 option 的主商品价。
       // 优先级：main_product_selling_price（per-unit 券后 source）> price（还原/good_pass 分支）>
       // total/num（仅当 Rules 只给 total 时的兜底）> 保留当前 source。
       const nextSourceSellingPrice = values.main_product_selling_price !== undefined ? String(values.main_product_selling_price) : values.price !== undefined ? String(values.price) : values.total !== undefined ? toUnitPriceString(values.total, nextNum) : String(existedSource);
@@ -956,8 +975,8 @@ function createDefaultOrderRulesHooks(getBookings) {
       // 缺省时保留现有 source（券前 = 当前 source）。
       const nextSourceOriginalPrice = values.original_price !== undefined ? String(values.original_price) : String(existedSource);
 
-      // 含 option 的 main_product_*
-      const nextMainSellingPrice = new _decimal.default(Number(nextSourceSellingPrice) || 0).plus(optionSum).toDecimalPlaces(2).toFixed(2);
+      // 成交价只加回 option 折后合计；原价仍使用订单中保存的 option 原价。
+      const nextMainSellingPrice = new _decimal.default(Number(nextSourceSellingPrice) || 0).plus(optionSellingSum).toDecimalPlaces(2).toFixed(2);
       const nextMainOriginalPrice = new _decimal.default(Number(nextSourceOriginalPrice) || 0).plus(optionSum).toDecimalPlaces(2).toFixed(2);
       const nextBundle = values.bundle !== undefined ? mergeRulesBundlePrices(product.product_bundle, values.bundle) : product.product_bundle;
       const composedSellingPrice = composeLinePrice({
@@ -978,7 +997,7 @@ function createDefaultOrderRulesHooks(getBookings) {
         ...product,
         selling_price: composedSellingPrice,
         original_price: finalOriginalPrice,
-        discount_list: values.discount_list ?? product.discount_list,
+        discount_list: nextDiscountList,
         num: values.quantity ?? product.num,
         product_bundle: nextBundle,
         metadata: {

package/lib/modules/ResourcePlanner/planner.d.ts

@@ -1,5 +1,7 @@
 import type { AvailabilityProjection, AvailabilityProjectionInput, AvailabilityQuery, AvailabilityQueryResult, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, GetProductTimeRangesRequest, GetProductTimeRangesRuntimeOptions, ProductTimeRangeGroup } from './types';
 export declare function createAvailabilityProjection(input: AvailabilityProjectionInput): AvailabilityProjection;
+/** Resolve the label without changing the real calendar timestamp. */
+export declare function getDurationBusinessDate(projection: AvailabilityProjection, startAt: string): string;
 export declare function getProductTimeRanges(projection: AvailabilityProjection, request?: GetProductTimeRangesRequest, runtimeOptions?: GetProductTimeRangesRuntimeOptions): ProductTimeRangeGroup[];
 export declare function queryAvailabilityProjection(projection: AvailabilityProjection, request: AvailabilityQuery, runtimeOptions?: GetProductTimeRangesRuntimeOptions): AvailabilityQueryResult;
 export declare function validateAvailabilitySelection(projection: AvailabilityProjection, params: AvailabilitySelectionValidationParams, runtimeOptions?: GetProductTimeRangesRuntimeOptions): AvailabilitySelectionValidationResult;