@pisell/pisellos 2.2.314 → 2.2.315

package/lib/solution/UnifiedBookingSales/index.js

@@ -32,6 +32,8 @@ exports.normalizeProductForAvailability = normalizeProductForAvailability;
 var _dayjs = _interopRequireDefault(require("dayjs"));
 var _lodashEs = require("lodash-es");
 var _modules = require("../../modules");
+var _pickupTiming = require("../../modules/Order/pickupTiming");
+var _cacheItemToBookingInput = require("../../modules/BookingContext/utils/cacheItemToBookingInput");
 var _utils = require("../../modules/BookingContext/utils");
 var _OpenData = require("../../modules/OpenData");
 var _getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
@@ -49,13 +51,13 @@ Object.keys(_types).forEach(function (key) {
   });
 });
 var _remoteOccupancyCache = require("./remoteOccupancyCache");
+var _businessAvailability = require("./businessAvailability");
 var _BookingTicket = require("../BookingTicket");
 var _localClock = require("../../modules/ResourcePlanner/localClock");
 var _platform = require("../../utils/platform");
 var _itemRule = require("../../model/strategy/adapter/itemRule");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const OPEN_DATA_SECTION_CODES = ['sale', 'reservation', 'fulfillment', 'menu', 'workflow', 'documents', 'basic', 'checkout', 'availability'];
-const OPEN_DATA_CACHE_TTL = 5 * 60 * 1000;
 function normalizePositiveInteger(value) {
   const normalized = Number(value);
   if (!Number.isInteger(normalized) || normalized <= 0) return undefined;
@@ -865,6 +867,20 @@ function collectAvailabilityResourceIds(products, explicitResourceIds = []) {
 function getProductLineUid(product) {
   return String(product?.metadata?.unique_identification_number ?? product?.unique_identification_number ?? '');
 }
+function getVisibleCalendarDate(value) {
+  if (typeof value !== 'string') return null;
+  const raw = value.trim();
+  try {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+      (0, _localClock.parseLocalDate)(raw);
+    } else {
+      (0, _localClock.parseLocalDateTime)(raw);
+    }
+    return raw.slice(0, 10);
+  } catch (_error) {
+    return null;
+  }
+}
 function buildAvailabilityLineIdentity(product) {
   return {
     product_id: product.product_id,
@@ -1198,6 +1214,14 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
   defaultName = 'unifiedBookingSales';
   defaultVersion = '1.0.0';
   store = {};
+  pickupTimingEnabled = true;
+  businessAvailabilityController;
+  runtimeOpenDataScope = null;
+  runtimeOpenDataSnapshot = null;
+  runtimeOpenDataModule = null;
+  runtimeOpenDataCore;
+  runtimeOpenDataGeneration = 0;
+  runtimeOpenDataDestroyed = false;
   unifiedProductCatalog = [];
   availabilityRuntimeOffsetMinutes = null;
   availabilityScheduleCatalog = null;
@@ -1217,23 +1241,75 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
   allergyItemRuleConfigs = [];
   allergyItemRuleConfigsPromise = null;
   async initialize(core, options = {}) {
+    this.resetRuntimeOpenData();
+    this.runtimeOpenDataDestroyed = false;
+    const openDataGeneration = this.runtimeOpenDataGeneration;
     this.availabilityScheduleCatalog = null;
-    this.openDataTarget = null;
     this.availabilityRuntimeOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)();
     this.clearAvailabilityRemoteResourceState();
     this.resetAllergyItemRuleState();
     await super.initialize(core, options);
-    const openDataBusinessCode = String(this.otherParams?.businessCode ?? this.otherParams?.business_code ?? '').trim();
-    const openDataChannel = String(this.otherParams?.channel ?? '').trim();
-    if (this.otherParams?.openData && openDataBusinessCode && openDataChannel) {
-      this.openDataTarget = `${openDataBusinessCode}+${openDataChannel}`;
+    if (this.runtimeOpenDataDestroyed || openDataGeneration !== this.runtimeOpenDataGeneration) {
+      throw new Error('Store settings changed. Please try again.');
     }
     this.captureAvailabilityScheduleCatalog();
+    await this.ensureAllergyItemRuleConfigsLoaded();
   }
   getSubmitOrderSalesChannel() {
     const channel = String(this.otherParams?.channel ?? '').trim();
     return channel || super.getSubmitOrderSalesChannel();
   }
+
+  /** Only the explicit Kiosk Sales consumer entry enables this policy; POS stays unchanged. */
+  isBusinessAvailabilityEnabled() {
+    return this.otherParams?.enableBusinessAvailability === true && ['pc', 'h5', 'kiosk'].includes((0, _platform.normalizeRuntimePlatform)(this.otherParams?.platform));
+  }
+  getBusinessAvailabilityScope() {
+    return `${this.getRuntimeOpenDataScope()}:${this.runtimeOpenDataGeneration}`;
+  }
+  getBusinessAvailabilityController() {
+    if (!this.businessAvailabilityController) {
+      this.businessAvailabilityController = new _businessAvailability.BusinessAvailabilityController({
+        loadOpenData: () => this.loadOpenDataConfig(),
+        getSchedule: () => this.store.schedule,
+        getTimezone: () => String(this.otherParams?.businessTimezone || this.getPickupTimingContextData('timezone') || ''),
+        getScope: () => this.getBusinessAvailabilityScope()
+      });
+    }
+    return this.businessAvailabilityController;
+  }
+  getBusinessAvailability() {
+    return this.getBusinessAvailabilityController().getAvailability();
+  }
+
+  /** Internal final-write assertion; does not fetch OpenData or Schedule. */
+  assertBusinessAvailability() {
+    if (this.isBusinessAvailabilityEnabled()) this.getBusinessAvailabilityController().assertAvailable();
+  }
+  getSubModuleHooks(moduleName) {
+    const hooks = super.getSubModuleHooks(moduleName);
+    if (moduleName !== 'order' || !this.isBusinessAvailabilityEnabled()) return hooks;
+    let lastScope;
+    let lastExistingScope;
+    let scopeToken = {};
+    return {
+      ...hooks,
+      getCartIntentScope: () => {
+        const scope = this.getBusinessAvailabilityScope();
+        const existingScope = hooks?.getCartIntentScope?.();
+        if (scope !== lastScope || !Object.is(existingScope, lastExistingScope)) {
+          lastScope = scope;
+          lastExistingScope = existingScope;
+          scopeToken = {};
+        }
+        return scopeToken;
+      },
+      beforeCartIntentCommit: context => {
+        this.assertBusinessAvailability();
+        hooks?.beforeCartIntentCommit?.(context);
+      }
+    };
+  }
   createAvailabilityFacadeError(code, message, details) {
     return new _ResourcePlanner.AvailabilityError(code, message, details);
   }
@@ -1246,6 +1322,26 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       businessTimezone: String(otherParams.businessTimezone ?? '')
     };
   }
+  usesDurationTimeGrid(projection) {
+    const platform = String(this.otherParams?.platform ?? '').trim().toLowerCase();
+    return (platform === 'pos' || platform === 'kiosk') && (!projection || projection.products.some(product => product.kind === 'duration'));
+  }
+  getCurrentAvailabilityBusinessDate(projection) {
+    return (0, _ResourcePlanner.getDurationBusinessDate)(projection, this.getAvailabilityRuntimeDateTime());
+  }
+  getAvailabilityBusinessDateRange(projection) {
+    const prepare = projection.meta.prepareParams;
+    const range = prepare?.dateRange;
+    if (!this.usesDurationTimeGrid(projection) || !range?.startDate || !range.endDate) {
+      return projection.meta.coverage;
+    }
+    const businessDate = this.getCurrentAvailabilityBusinessDate(projection);
+    const today = this.getAvailabilityRuntimeDateTime().slice(0, 10);
+    return {
+      startDate: range.startDate === today && businessDate < today ? businessDate : range.startDate,
+      endDate: range.endDate
+    };
+  }
   normalizeAvailabilityIdList(values) {
     if (!Array.isArray(values) || values.length === 0) return undefined;
     const uniqueMap = new Map();
@@ -1289,6 +1385,90 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       mode
     });
   }
+
+  /**
+   * 列表直加没有经过 SKU availability flow，legacy cacheItem 的灵活时长可能落到
+   * 23:59。提交前用同一套营业排期补齐结束时间，保留已选开始时间、资源和 Holder。
+   * 仅供直加调用；手动时间选择和 availability candidate 不经过此方法。
+   */
+  async prepareDirectAddFlexibleBooking(cacheItem) {
+    if (!(0, _utils.isProductFlexibleDuration)(cacheItem?.duration) || (0, _utils.isSessionProduct)(cacheItem)) {
+      return cacheItem;
+    }
+    const extend = cacheItem?._extend;
+    const {
+      startDate
+    } = (0, _utils.getServiceTimes)(cacheItem);
+    if (!extend?.start_date || !extend?.start_time || !startDate.isValid()) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', '灵活时长商品缺少有效开始时间');
+    }
+    const date = startDate.format('YYYY-MM-DD');
+    // 带上前一天，覆盖凌晨仍处在前一营业时段内的情况。
+    const dateRange = {
+      startDate: startDate.subtract(1, 'day').format('YYYY-MM-DD'),
+      endDate: date
+    };
+    const prepare = await this.resolveAvailabilityPrepareDefaults({
+      dateRange
+    });
+    if (prepare._availabilityOperatingHours?.source !== 'open_data_schedule') {
+      return cacheItem;
+    }
+    const operatingHours = this.buildAvailabilityOperatingHoursSnapshot({
+      prepare,
+      dateRange,
+      scheduleList: this.getAvailabilityScheduleCatalog(),
+      businessHours: DEFAULT_AVAILABILITY_BUSINESS_HOURS
+    });
+    if (operatingHours.missingScheduleIds.length > 0) {
+      throw new _ResourcePlanner.AvailabilityError('OPERATING_HOURS_RESOLVE_FAILED', '店铺营业时间排期缺失，请重试', {
+        missingScheduleIds: operatingHours.missingScheduleIds
+      });
+    }
+    const start = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(startDate.format('YYYY-MM-DDTHH:mm:00')));
+    const nextDay = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(`${startDate.add(1, 'day').format('YYYY-MM-DD')}T00:00:00`));
+    const windows = operatingHours.windows.map(window => ({
+      start: (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(window.startAt)),
+      end: (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(window.endAt))
+    })).filter(window => window.end > start && window.start < nextDay).sort((left, right) => left.start - right.start);
+    const merged = [];
+    for (const window of windows) {
+      const previous = merged[merged.length - 1];
+      if (previous && window.start <= previous.end) {
+        previous.end = Math.max(previous.end, window.end);
+      } else {
+        merged.push({
+          ...window
+        });
+      }
+    }
+    // POS 可以提前售票；保留开始分钟，结束取当前或当天下一段营业时间。
+    // 不跨越午休，也不把闭店后的直加顺延到次日。
+    let end = merged[0]?.end;
+    const resourceEndAt = (0, _utils.getUsableTime)(cacheItem)?._extend?.usableTime?.end_at;
+    if (resourceEndAt) {
+      const resourceEnd = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)((0, _dayjs.default)(resourceEndAt).format('YYYY-MM-DDTHH:mm:00')));
+      if (end !== undefined) end = Math.min(end, resourceEnd);
+    }
+    if (end === undefined || end <= start) {
+      throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '当前时间没有可用营业时段，请选择预约时间');
+    }
+    const duration = Math.floor((end - start) / 60000);
+    if (duration <= 0) {
+      throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '灵活时长商品的结束时间必须晚于开始时间');
+    }
+    const endDate = (0, _dayjs.default)((0, _localClock.formatLocalDateTime)(start + duration * 60000));
+    return {
+      ...cacheItem,
+      _extend: {
+        ...extend,
+        duration: _utils.flexibleObj.create(duration),
+        endDate,
+        end_date: endDate.format('YYYY-MM-DD'),
+        end_time: endDate.format('HH:mm')
+      }
+    };
+  }
   async resolveAvailabilityPrepareDefaults(params) {
     const needsOperatingHours = params.businessHours === undefined;
     const needsTimeSlice = params.slotStepMinutes === undefined;
@@ -1304,7 +1484,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     const businessCode = String(this.otherParams?.businessCode ?? this.otherParams?.business_code ?? '').trim();
     const channel = String(this.otherParams?.channel ?? '').trim();
     const currentTarget = businessCode && channel ? `${businessCode}+${channel}` : null;
-    let openData = !currentTarget || this.openDataTarget === currentTarget ? this.otherParams?.openData : null;
+    let openData = (!currentTarget || this.openDataTarget === currentTarget) && (this.runtimeOpenDataScope === null || this.runtimeOpenDataScope === this.getRuntimeOpenDataScope()) ? this.otherParams?.openData : null;
     if (!openData && this.store.openData) {
       try {
         openData = await this.getOpenData();
@@ -1368,6 +1548,13 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     const previousScope = this.getAvailabilityScopeDescriptor(this.otherParams || {});
     const previousItemRuleConfig = this.otherParams?.itemRule;
     const explicitlySetsOpenData = Object.prototype.hasOwnProperty.call(params, 'openData');
+    const nextParams = cover ? params : {
+      ...this.otherParams,
+      ...params
+    };
+    if (explicitlySetsOpenData || this.getRuntimeOpenDataScope() !== this.getRuntimeOpenDataScope(nextParams)) {
+      this.clearOpenDataCache();
+    }
     await super.setOtherParams(params, {
       cover
     });
@@ -1384,6 +1571,8 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     }
   }
   async destroy() {
+    this.runtimeOpenDataDestroyed = true;
+    this.clearOpenDataCache();
     this.availabilityScheduleCatalog = null;
     this.availabilityRuntimeOffsetMinutes = null;
     await this.resetAvailabilityProjectionState('destroy');
@@ -1440,8 +1629,15 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     return typeof value === 'string' && value.trim() ? value : undefined;
   }
   createAvailabilityContextRef(context) {
+    const projection = this.getActiveAvailabilityProjectionEntry(context)?.projection;
     return {
-      contextId: context.contextId
+      contextId: context.contextId,
+      ...(projection && this.usesDurationTimeGrid(projection) ? {
+        durationTimeSelection: {
+          version: 1,
+          currentBusinessDate: this.getCurrentAvailabilityBusinessDate(projection)
+        }
+      } : {})
     };
   }
   async emitAvailabilityDiagnostic(payload) {
@@ -1579,6 +1775,42 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     this.store.order?.clearSessionStoragePersistedTempOrder?.();
   }
 
+  /** 在 Kiosk 拉起支付设备前补齐订单号，同一订单重试复用已分配的号码。 */
+  async ensureLocalOrderNumbersForCheckout() {
+    if ((0, _platform.normalizeRuntimePlatform)(this.otherParams?.platform) !== 'kiosk') return;
+    const order = this.store.order;
+    const tempOrder = order?.getTempOrder();
+    if (!tempOrder) throw new Error('当前订单不存在，无法生成订单编号');
+    if (tempOrder.shop_order_number && tempOrder.shop_full_order_number) return;
+    const biz = this.getBookingTicketBusinessCode();
+    if (!biz) throw new Error('当前订单缺少业务类型，无法生成订单编号');
+    const idGenerator = this.appPlugin?.getApp?.()?.getPlugin?.('idGenerator');
+    if (!tempOrder.shop_order_number && typeof idGenerator?.generateShopOrderNumber !== 'function' || !tempOrder.shop_full_order_number && typeof idGenerator?.generateReceiptId !== 'function') {
+      throw new Error('订单编号生成器不可用，请重启应用后重试');
+    }
+    try {
+      if (!tempOrder.shop_order_number) {
+        tempOrder.shop_order_number = await idGenerator.generateShopOrderNumber({
+          biz
+        });
+      }
+      if (!tempOrder.shop_full_order_number) {
+        tempOrder.shop_full_order_number = await idGenerator.generateReceiptId({
+          biz
+        });
+      }
+      if (order.getTempOrder() !== tempOrder) {
+        throw new Error('当前订单已切换，请重新发起支付');
+      }
+      if (!tempOrder.shop_order_number || !tempOrder.shop_full_order_number) {
+        throw new Error('订单编号生成失败，请重试');
+      }
+    } finally {
+      // 部分生成成功时也保留号码，后续只补仍然缺失的字段。
+      if (order.getTempOrder() === tempOrder) order.persistTempOrder();
+    }
+  }
+
   /**
    * PC/H5/Kiosk 结账默认直接等待云端 checkout；POS/WebPOS 仍保持本地待同步。
    * 显式传 checkoutSyncTaskEnabled: true 时仍可回退到本地同步模式。
@@ -1684,52 +1916,118 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       action: this.resolveDiscountAction(this.resolveDiscountOrderIdentity(tempOrder))
     });
   }
+  getRuntimeOpenDataScope(otherParams = this.otherParams) {
+    return JSON.stringify({
+      shop: this.getPickupTimingContextData('shop_id'),
+      appShop: this.appPlugin ? this.getAppData('shop_id') : undefined,
+      tenant: this.appPlugin ? this.getAppData('tenant_id') : undefined,
+      businessCode: String(otherParams?.businessCode ?? otherParams?.business_code ?? '').trim(),
+      channel: String(otherParams?.channel || super.getSubmitOrderSalesChannel()).trim(),
+      platform: (0, _platform.normalizeRuntimePlatform)(otherParams?.platform),
+      timezone: this.getPickupTimingContextData('timezone'),
+      businessTimezone: otherParams?.businessTimezone,
+      cacheId: otherParams === this.otherParams ? this.cacheId : otherParams?.cacheId
+    });
+  }
+  resetRuntimeOpenData() {
+    this.businessAvailabilityController?.invalidate();
+    this.runtimeOpenDataGeneration += 1;
+    this.runtimeOpenDataScope = null;
+    this.runtimeOpenDataSnapshot = null;
+    this.runtimeOpenDataModule = null;
+    this.runtimeOpenDataCore = undefined;
+    this.openDataTarget = null;
+    this.loadOpenDataInFlight = null;
+    this.loadOpenDataInFlightTarget = null;
+    this.otherParams = {
+      ...this.otherParams,
+      openData: null
+    };
+    this.store.openData?.clearCache?.();
+  }
+  async prepareInvoiceTemplateAtSolutionReady(injectedOpenData) {
+    const businessCode = this.getBookingTicketBusinessCode();
+    if (!businessCode || !this.store.openData) return;
+    if (injectedOpenData) {
+      this.otherParams.openData = injectedOpenData;
+      this.openDataTarget = `${businessCode}+${this.getSubmitOrderSalesChannel()}`;
+    }
+    try {
+      await this.loadOpenDataConfig();
+    } catch (error) {
+      console.warn('[UnifiedBookingSales] Invoice 模板预加载失败，使用默认配置', error);
+    }
+  }
+  async loadOpenDataConfig() {
+    const businessCode = this.getBookingTicketBusinessCode();
+    if (!businessCode) return null;
+    return this.loadOpenData({
+      businessCode,
+      channel: this.getSubmitOrderSalesChannel()
+    });
+  }
 
-  /**
-   * Loads OpenData without borrowing BookingTicket. Cache ownership is tied to the exact
-   * business/channel target so a reused solution instance cannot leak another entry's menus.
-   */
+  /** A successful configuration belongs to this business runtime until an explicit refresh. */
   async loadOpenData(params) {
-    if (!this.store.openData) {
+    const module = this.store.openData;
+    if (!module) {
       throw new Error('[UnifiedBookingSales] openData 模块未初始化');
     }
+    if (this.runtimeOpenDataDestroyed) {
+      throw new Error('Store settings changed. Please try again.');
+    }
     const businessCode = String(params.businessCode || '').trim();
     const channel = String(params.channel || '').trim();
     if (!businessCode || !channel) {
       throw new Error('[UnifiedBookingSales] OpenData 需要 businessCode 与 channel');
     }
     const target = `${businessCode}+${channel}`;
-    const cachedData = this.store.openData.getOpenData();
-    const lastFetchedAt = this.store.openData.getLastFetchedAt();
-    if (!params.force && this.openDataTarget === target && cachedData && lastFetchedAt && Date.now() - lastFetchedAt < OPEN_DATA_CACHE_TTL) {
-      if (typeof this.store.openData.ensureInvoiceTemplateSettings === 'function') {
-        await this.store.openData.ensureInvoiceTemplateSettings(target);
+    this.otherParams.businessCode = businessCode;
+    this.otherParams.channel = channel;
+    const scope = this.getRuntimeOpenDataScope();
+    if (params.force) {
+      this.clearOpenDataCache();
+    }
+    if (this.runtimeOpenDataScope !== scope || this.runtimeOpenDataModule !== module || this.runtimeOpenDataCore !== this.core) {
+      // Only the first, explicitly injected target may seed a new runtime snapshot.
+      const injectedOpenData = this.runtimeOpenDataScope === null && (!this.openDataTarget || this.openDataTarget === target) && isRecord(this.otherParams.openData) ? this.otherParams.openData : null;
+      if (this.runtimeOpenDataScope !== null) {
+        // The caller's Pickup Timing scope already changes with this runtime scope.
+        this.resetRuntimeOpenData();
       }
-      return cachedData;
+      this.runtimeOpenDataScope = scope;
+      this.runtimeOpenDataModule = module;
+      this.runtimeOpenDataCore = this.core;
+      this.runtimeOpenDataSnapshot = injectedOpenData;
     }
     if (this.loadOpenDataInFlight) {
-      if (this.loadOpenDataInFlightTarget === target) {
-        return await this.loadOpenDataInFlight;
+      return this.loadOpenDataInFlight;
+    }
+    const generation = this.runtimeOpenDataGeneration;
+    const core = this.core;
+    const request = (async () => {
+      let openData = this.runtimeOpenDataSnapshot;
+      if (openData) {
+        await module.ensureInvoiceTemplateSettings?.(target, openData);
+      } else {
+        openData = await module.fetchOpenData({
+          scope: 'board',
+          target,
+          section_code: [...OPEN_DATA_SECTION_CODES]
+        });
       }
-      await this.loadOpenDataInFlight;
-      return this.loadOpenData(params);
-    }
+      if (this.runtimeOpenDataDestroyed || generation !== this.runtimeOpenDataGeneration || scope !== this.getRuntimeOpenDataScope() || module !== this.store.openData || core !== this.core) {
+        throw new Error('Store settings changed. Please try again.');
+      }
+      this.runtimeOpenDataSnapshot = openData;
+      this.openDataTarget = target;
+      this.otherParams.openData = openData;
+      return openData;
+    })();
     this.loadOpenDataInFlightTarget = target;
-    const request = this.store.openData.fetchOpenData({
-      scope: 'board',
-      target,
-      section_code: [...OPEN_DATA_SECTION_CODES]
-    });
     this.loadOpenDataInFlight = request;
     try {
-      const openData = await request;
-      if (this.loadOpenDataInFlight === request) {
-        this.openDataTarget = target;
-        this.otherParams.openData = openData;
-        this.otherParams.businessCode = businessCode;
-        this.otherParams.channel = channel;
-      }
-      return openData;
+      return await request;
     } finally {
       if (this.loadOpenDataInFlight === request) {
         this.loadOpenDataInFlight = null;
@@ -1738,13 +2036,19 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     }
   }
   async getOpenData() {
-    const businessCode = String(this.otherParams?.businessCode || '').trim();
-    const channel = String(this.otherParams?.channel || '').trim();
-    if (!businessCode || !channel) return null;
-    return this.loadOpenData({
+    return this.loadOpenDataConfig();
+  }
+  async loadPickupTimingOpenData(_force) {
+    const scope = this.getPickupTimingScope();
+    const businessCode = String(this.otherParams?.businessCode ?? this.otherParams?.business_code ?? '').trim();
+    const config = await this.loadOpenData({
       businessCode,
-      channel
+      channel: this.getSubmitOrderSalesChannel()
     });
+    if (scope !== this.getPickupTimingScope()) {
+      throw new Error('Store settings changed. Please try again.');
+    }
+    return config;
   }
   resetAllergyItemRuleState() {
     this.allergyItemRuleConfigs = [];
@@ -1797,7 +2101,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       this.allergyItemRuleConfigs = loaded;
       this.allergyItemRuleEvaluator.setStrategyConfigs(loaded);
       return loaded;
-    })();
+    })().catch(() => []);
     return this.allergyItemRuleConfigsPromise;
   }
 
@@ -1839,10 +2143,8 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     });
   }
   clearOpenDataCache() {
-    this.openDataTarget = null;
-    this.loadOpenDataInFlight = null;
-    this.loadOpenDataInFlightTarget = null;
-    super.clearOpenDataCache();
+    this.resetRuntimeOpenData();
+    this.resetPickupTimingCache();
   }
   async getInvoiceLayoutConfig() {
     const openData = await this.getOpenData();
@@ -1862,7 +2164,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     const businessCode = String(this.otherParams?.businessCode || '').trim();
     const channel = String(this.otherParams?.channel || '').trim();
     if (!businessCode || !channel) return false;
-    return this.openDataTarget === `${businessCode}+${channel}`;
+    return this.openDataTarget === `${businessCode}+${channel}` && this.runtimeOpenDataScope === this.getRuntimeOpenDataScope();
   }
 
   /**
@@ -2274,7 +2576,9 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         return range ? [{
           startAt: range.startAt,
           endAt: range.endAt,
-          source: descriptor.source
+          source: descriptor.source,
+          businessDate: date,
+          openingAnchorAt: range.startAt
         }] : [];
       });
       return {
@@ -2298,7 +2602,8 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       return range ? [{
         startAt: range.startAt,
         endAt: range.endAt,
-        source: `operating_schedule:${descriptor.scheduleIds.map(String).join(',')}`
+        source: `operating_schedule:${descriptor.scheduleIds.map(String).join(',')}`,
+        businessDate: date
       }] : [];
     }));
     const excludedWindows = dateRangeDays(params.dateRange).flatMap(date => schedules.flatMap(schedule => getExcludedScheduleDateOverrideTimePoints(date, schedule).flatMap(slot => {
@@ -2312,12 +2617,23 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         startAt: range.startAt,
         endAt: range.endAt,
         source: `operating_schedule_excluded:${schedule.id}`,
+        businessDate: date,
         raw: {
           scheduleId: schedule.id,
           excludedDate: date
         }
       }] : [];
     })));
+    // All lunch-break windows share the first opening of their business day.
+    const openings = new Map();
+    [...windows, ...excludedWindows].forEach(window => {
+      const date = window.businessDate || window.startAt.slice(0, 10);
+      const previous = openings.get(date);
+      if (!previous || window.startAt < previous) openings.set(date, window.startAt);
+    });
+    [...windows, ...excludedWindows].forEach(window => {
+      window.openingAnchorAt = openings.get(window.businessDate || window.startAt.slice(0, 10));
+    });
     return {
       source: descriptor.source,
       scheduleIds: [...descriptor.scheduleIds],
@@ -2707,24 +3023,34 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     const normalizedPrepareParams = this.normalizeAvailabilityPrepareDescriptor(params);
     const timezoneLabel = String(normalizedPrepareParams.timezone);
     const dateRange = normalizedPrepareParams.dateRange;
+    const scheduleList = this.getAvailabilityScheduleCatalog();
+    const products = await this.loadAvailabilityProducts({
+      prepare: normalizedPrepareParams,
+      dateRange,
+      scheduleList
+    });
+    // Coverage is physical local time; the caller's date range remains business
+    // dates. Keep yesterday's opening and the last business day's overnight tail.
+    const useDurationTimeGrid = this.usesDurationTimeGrid() && products.some(product => product.kind === 'duration');
+    const coverageDateRange = useDurationTimeGrid ? {
+      startDate: (0, _localClock.formatLocalDate)((0, _localClock.addLocalCalendarDays)((0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(dateRange.startDate)), -1)),
+      endDate: (0, _localClock.formatLocalDate)((0, _localClock.addLocalCalendarDays)((0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(dateRange.endDate)), 1))
+    } : dateRange;
     const slotStepMinutes = normalizedPrepareParams.slotStepMinutes || DEFAULT_AVAILABILITY_SLOT_STEP_MINUTES;
     const businessHours = normalizedPrepareParams.businessHours || DEFAULT_AVAILABILITY_BUSINESS_HOURS;
     const mode = normalizedPrepareParams.mode || 'appointment';
-    const scheduleList = this.getAvailabilityScheduleCatalog();
     const operatingHours = this.buildAvailabilityOperatingHoursSnapshot({
       prepare: normalizedPrepareParams,
-      dateRange,
+      dateRange: useDurationTimeGrid ? {
+        startDate: coverageDateRange.startDate,
+        endDate: dateRange.endDate
+      } : dateRange,
       scheduleList,
       businessHours
     });
-    const products = await this.loadAvailabilityProducts({
-      prepare: normalizedPrepareParams,
-      dateRange,
-      scheduleList
-    });
     const loadedResources = await this.loadAvailabilityResources({
       timezone: timezoneLabel,
-      dateRange,
+      dateRange: coverageDateRange,
       resourceIds: normalizedPrepareParams.resourceIds,
       products,
       rawResources: normalizedPrepareParams.rawResources,
@@ -2760,7 +3086,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       resourceOccupancies: [...remoteOccupancies, ...cartOccupancies],
       mode,
       timezone: timezoneLabel,
-      coverage: dateRange,
+      coverage: coverageDateRange,
       slotStepMinutes,
       businessHours,
       operatingHours,
@@ -3015,14 +3341,47 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     } = await this.ensureAvailabilityContextProjection(contextId, 'get_product_time_ranges');
     const contextVersion = context.activeVersion;
     const isPosAvailabilityRequest = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos';
-    const allowOutsideOperatingHoursForRequestedStartTimes = isPosAvailabilityRequest && Object.values(request.durationStartTimesByProductId || {}).some(startTimes => Array.isArray(startTimes) && startTimes.length > 0);
+    const isEditingContext = Boolean(context.prepareParams.editingProductLineUids?.length);
+    const editingOffset = (0, _localClock.extractFixedOffsetMinutes)(projectionEntry.projection.meta.now) ?? this.getAvailabilityRuntimeOffsetMinutes();
+    // This new editing input represents an absolute instant. Normalize it once
+    // to the projection's fixed business clock before the wall-clock planner.
+    const editingStartAtByProductId = isEditingContext && request.editingStartAtByProductId ? Object.fromEntries(Object.entries(request.editingStartAtByProductId).map(([productId, startAt]) => {
+      try {
+        const scalar = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(startAt));
+        const inputOffset = (0, _localClock.extractFixedOffsetMinutes)(startAt) ?? editingOffset;
+        return [productId, (0, _localClock.formatLocalDateTime)(scalar + (editingOffset - inputOffset) * 60000, editingOffset)];
+      } catch {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', '编辑开始时间必须是完整有效日期时间');
+      }
+    })) : undefined;
+    let dateRange = request.dateRange || this.getAvailabilityBusinessDateRange(projectionEntry.projection);
+    // Older edit drafts carry the real calendar date, not a business-date label.
+    // The explicit absolute start disambiguates the previous day's overnight tail.
+    const editingStarts = Object.values(editingStartAtByProductId || {});
+    if (this.usesDurationTimeGrid(projectionEntry.projection) && editingStarts.length === 1 && dateRange.startDate === dateRange.endDate && dateRange.startDate === (0, _localClock.formatLocalDate)((0, _localClock.parseLocalDateTime)(editingStarts[0]))) {
+      const businessDate = (0, _ResourcePlanner.getDurationBusinessDate)(projectionEntry.projection, editingStarts[0]);
+      dateRange = {
+        startDate: businessDate,
+        endDate: businessDate
+      };
+    }
+    const rememberedStartAtByProductId = isPosAvailabilityRequest && !isEditingContext ? request.rememberedStartAtByProductId : undefined;
+    const allowOutsideOperatingHoursForRequestedStartTimes = isPosAvailabilityRequest && !rememberedStartAtByProductId && (editingStarts.length > 0 || Object.values(request.durationStartTimesByProductId || {}).some(startTimes => Array.isArray(startTimes) && startTimes.length > 0));
     return (0, _ResourcePlanner.getProductTimeRanges)(projectionEntry.projection, {
       ...request,
+      dateRange,
+      editingStartAtByProductId,
+      rememberedStartAtByProductId,
+      ...(rememberedStartAtByProductId ? {
+        allowOutsideOperatingHoursForRequestedStartTimes: false
+      } : {}),
       ...(allowOutsideOperatingHoursForRequestedStartTimes ? {
         allowOutsideOperatingHoursForRequestedStartTimes: true
       } : {})
     }, {
       evaluatedAt: this.getAvailabilityRuntimeDateTime(),
+      useDurationTimeGrid: this.usesDurationTimeGrid(projectionEntry.projection),
+      enforceSaleCutoff: Boolean(rememberedStartAtByProductId),
       useExactDurationCandidateMinute: isPosAvailabilityRequest,
       allowSessionCustomRanges: isPosAvailabilityRequest,
       allowExcludedScheduleDateOverride: isPosAvailabilityRequest
@@ -3041,7 +3400,13 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     } = await this.ensureAvailabilityContextProjection(contextId, 'query_booking_availability');
     this.assertContextualQueryFreshness(context, request);
     const isPosAvailabilityRequest = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos';
-    const result = (0, _ResourcePlanner.queryAvailabilityProjection)(projectionEntry.projection, request, {
+    const queryRequest = request.target === 'date' || request.target === 'product' ? {
+      ...request,
+      dateRange: request.dateRange || this.getAvailabilityBusinessDateRange(projectionEntry.projection)
+    } : request;
+    const result = (0, _ResourcePlanner.queryAvailabilityProjection)(projectionEntry.projection, queryRequest, {
+      useDurationTimeGrid: this.usesDurationTimeGrid(projectionEntry.projection),
+      enforceSaleCutoff: isPosAvailabilityRequest && !context.prepareParams.editingProductLineUids?.length && request.selectionIntent === 'remembered',
       useExactDurationCandidateMinute: isPosAvailabilityRequest,
       allowExcludedScheduleDateOverride: isPosAvailabilityRequest
     });
@@ -3121,6 +3486,24 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     const bookingUid = String(product.booking_uid ?? product.metadata?.booking_uid ?? '');
     return (this.getTempOrder()?.bookings || []).find(booking => bookingUid && getBookingUid(booking) === bookingUid || productUid && String(booking.product_uid ?? '') === productUid);
   }
+  async removeBookingProductsOutsideStartDate(startDate) {
+    const products = this.getTempOrder()?.products || [];
+    if (this.otherParams?.enforceSingleBookingStartDate !== true) {
+      return products;
+    }
+    const targetDate = getVisibleCalendarDate(startDate);
+    if (!targetDate) return products;
+    const identities = products.flatMap(product => {
+      if (!getProductLineUid(product) || product?.metadata?.product_add_schedule_time != null) {
+        return [];
+      }
+      const booking = this.findLinkedBooking(product);
+      if (!booking || (0, _pickupTiming.isFulfillmentTimingBooking)(booking)) return [];
+      const bookingDate = getVisibleCalendarDate(booking.start_date);
+      return bookingDate && bookingDate !== targetDate ? [buildAvailabilityLineIdentity(product)] : [];
+    });
+    return identities.length ? this.removeProductsFromOrder(identities) : products;
+  }
 
   /** Revalidates against the latest landed occupancy cache, then mutates exactly one product line. */
   async commitAvailabilitySelection(contextId, params) {
@@ -3130,6 +3513,25 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         candidate: params.candidate
       });
     }
+    const isRememberedSelection = params.selectionIntent === 'remembered';
+    if (isRememberedSelection && (String(this.otherParams?.platform ?? '').trim().toLowerCase() !== 'pos' || params.mode !== 'add')) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', '记忆时间自动提交仅支持 POS 新增 duration 商品');
+    }
+    const hasCommitGuard = isRememberedSelection || Boolean(params.availabilityCommitGuard);
+    params.availabilityCommitGuard?.();
+    // Stabilize the locally generated sale identity before taking the guard snapshot.
+    if (hasCommitGuard) this.store.order?.ensureTempOrder?.();
+    const rememberedOrder = hasCommitGuard ? this.getTempOrder() : null;
+    const getRememberedCommitIdentity = () => JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      shopId: this.otherParams?.shop_id ?? this.otherParams?.shopId,
+      contextShopId: this.core?.context?.shop_id,
+      orderId: this.getTempOrder()?.order_id,
+      externalSaleNumber: this.getTempOrder()?.external_sale_number
+    }));
+    const rememberedCommitIdentity = hasCommitGuard ? getRememberedCommitIdentity() : '';
+    const availabilityCommitTargetGuard = () => this.getTempOrder() === rememberedOrder && getRememberedCommitIdentity() === rememberedCommitIdentity;
+    let guardedCommitPublished = false;
     await this.tryAcquireAvailabilityCommitLock(normalizedContextId);
     try {
       const bookingCount = Number(params.bookingCount ?? 1);
@@ -3235,6 +3637,10 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         });
       }
       const baseProjection = projectionEntry.projection;
+      const selectedProduct = baseProjection.products.find(item => sameAvailabilityId(item.id, params.candidate.productId));
+      if (isRememberedSelection && (String(this.otherParams?.platform ?? '').trim().toLowerCase() !== 'pos' || params.mode !== 'add' || selectedProduct?.kind !== 'duration')) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', '记忆时间自动提交仅支持 POS 新增 duration 商品');
+      }
       let commitWriteGuard = {
         contextId: normalizedContextId,
         expectedVersion: context.activeVersion,
@@ -3280,17 +3686,32 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       this.assertAvailabilityCommitWriteCAS(commitWriteGuard);
       const candidateDurationMinutes = getCandidateDurationMinutes(params.candidate);
       const candidateStartTime = getCandidateStartTime(params.candidate);
-      const allowPosAvailabilityOverride = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos';
+      const allowPosAvailabilityOverride = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos' && !isRememberedSelection;
+      const candidateBusinessDate = params.candidate.businessDate || (selectedProduct?.kind === 'duration' && this.usesDurationTimeGrid(refreshedProjection) ? (0, _ResourcePlanner.getDurationBusinessDate)(refreshedProjection, params.candidate.startAt) : params.candidate.startAt.slice(0, 10));
       const refreshedRanges = (0, _ResourcePlanner.getProductTimeRanges)(refreshedProjection, {
         productIds: [params.candidate.productId],
         dateRange: {
-          startDate: params.candidate.startAt.slice(0, 10),
-          endDate: params.candidate.startAt.slice(0, 10)
+          startDate: candidateBusinessDate,
+          endDate: candidateBusinessDate
         },
-        ...(candidateDurationMinutes ? {
+        ...(isRememberedSelection ? {
+          rememberedStartAtByProductId: {
+            [String(params.candidate.productId)]: params.candidate.bookingStartAt
+          },
+          ...(!selectedProduct?.isFlexibleDuration && candidateDurationMinutes ? {
+            durationMinutesByProductId: {
+              [String(params.candidate.productId)]: candidateDurationMinutes
+            }
+          } : {})
+        } : candidateDurationMinutes ? {
           durationMinutesByProductId: {
             [String(params.candidate.productId)]: candidateDurationMinutes
           },
+          ...(params.mode === 'edit' && selectedProduct?.kind === 'duration' ? {
+            editingStartAtByProductId: {
+              [String(params.candidate.productId)]: params.candidate.bookingStartAt
+            }
+          } : {}),
           ...(candidateStartTime ? {
             durationStartTimesByProductId: {
               [String(params.candidate.productId)]: [candidateStartTime]
@@ -3301,6 +3722,9 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
           } : {})
         } : {})
       }, {
+        evaluatedAt: this.getAvailabilityRuntimeDateTime(),
+        useDurationTimeGrid: this.usesDurationTimeGrid(refreshedProjection),
+        enforceSaleCutoff: isRememberedSelection,
         useExactDurationCandidateMinute: allowPosAvailabilityOverride,
         allowSessionCustomRanges: allowPosAvailabilityOverride,
         allowExcludedScheduleDateOverride: allowPosAvailabilityOverride
@@ -3325,6 +3749,8 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         partySize,
         bookingCount
       }, {
+        useDurationTimeGrid: this.usesDurationTimeGrid(refreshedProjection),
+        enforceSaleCutoff: isRememberedSelection,
         useExactDurationCandidateMinute: allowPosAvailabilityOverride,
         allowExcludedScheduleDateOverride: allowPosAvailabilityOverride
       });
@@ -3385,6 +3811,30 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         expectedOrderRevision: revalidationEntry.orderRevision
       };
       const refreshedCandidate = this.decorateAvailabilityCandidate(normalizedContextId, revalidatedContext.activeVersion, refreshedCandidateBase);
+      // Order may await line/runtime setup. Its guarded transaction invokes this
+      // again immediately before publishing, while the live cart is unchanged.
+      const availabilityCommitGuard = hasCommitGuard ? () => {
+        params.availabilityCommitGuard?.();
+        this.assertAvailabilityCommitWriteCAS(commitWriteGuard);
+        if (!availabilityCommitTargetGuard()) {
+          throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '记忆时间加购期间订单或业务已变化');
+        }
+        if (!isRememberedSelection) return;
+        const currentValidation = (0, _ResourcePlanner.validateAvailabilitySelection)(refreshedProjection, {
+          candidate: refreshedCandidateBase,
+          requirementSelections: params.requirementSelections,
+          partySize,
+          bookingCount
+        }, {
+          useDurationTimeGrid: true,
+          enforceSaleCutoff: true
+        });
+        if (!currentValidation.ok) {
+          throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '记忆时间在加购前已不可用，请重新选择', {
+            validation: currentValidation
+          });
+        }
+      } : undefined;
       const existingBooking = editingLine ? this.findLinkedBooking(editingLine) : undefined;
       const existingBookingUid = existingBooking ? getBookingUid(existingBooking) : '';
       if (params.mode === 'edit' && !existingBookingUid) {
@@ -3402,6 +3852,23 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         holder: params.orderProduct?._extend?.holder ?? existingBooking?.holder ?? existingBooking?.metadata?.holder,
         holderIds: params.orderProduct?._extend?.holder_id ?? params.orderProduct?._extend?.holder?.form_record ?? existingBooking?.metadata?.holder_id ?? existingBooking?.holder?.form_record
       });
+      if (isRememberedSelection && params.orderProduct?._extend?.resource) {
+        // AutoClose 与编辑共用旧资源协议。仅复用其结构，实际资源及每份容量
+        // 必须与本次严格校验结果一致；时间、Holder 和校验元数据仍使用上面的结果。
+        const legacyBooking = (0, _cacheItemToBookingInput.cacheItemToBookingInput)(params.orderProduct);
+        const legacyResources = legacyBooking.resources || [];
+        const selectedResources = legacyResources.filter(resource => Number(resource.relation_id) !== 0);
+        const resourceKeys = resources => resources.map(resource => JSON.stringify([String(resource.form_id), String(resource.relation_id), resource.relation_type, Number(resource.capacity)])).sort();
+        if (JSON.stringify(resourceKeys(selectedResources)) !== JSON.stringify(resourceKeys(booking.resources)) || legacyResources.some(resource => Number(resource.relation_id) === 0 && !selectedResources.some(selected => sameAvailabilityId(selected.form_id, resource.form_id)))) {
+          throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '记忆时间的资源与本次校验结果不一致');
+        }
+        Object.assign(booking, {
+          relation_id: legacyBooking.relation_id,
+          form_id: legacyBooking.form_id,
+          relation_type: legacyBooking.relation_type,
+          resources: (0, _lodashEs.cloneDeep)(legacyResources)
+        });
+      }
       const transformed = this.buildUnifiedOrderProduct({
         ...params.orderProduct,
         num: bookingCount,
@@ -3447,6 +3914,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
             allow_booking_discount_reapply: params.allowBookingDiscountReapply
           } : {})
         });
+        await this.removeBookingProductsOutsideStartDate(booking.start_date);
         productLineUid = params.productLineUid;
         bookingUid = existingBookingUid;
         productLineUids = [productLineUid];
@@ -3454,12 +3922,21 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       } else {
         const beforeProductLineUids = new Set((this.getTempOrder()?.products || []).map(line => getProductLineUid(line)).filter(Boolean));
         const beforeBookingUids = new Set((this.getTempOrder()?.bookings || []).map(item => getBookingUid(item)).filter(Boolean));
-        const products = await this.addProductToOrder(transformed, booking, params.salesNotes?.length ? {
-          salesNotes: params.salesNotes
+        availabilityCommitGuard?.();
+        let products = await this.addProductToOrder(transformed, booking, params.salesNotes?.length || availabilityCommitGuard ? {
+          ...(params.salesNotes?.length ? {
+            salesNotes: params.salesNotes
+          } : {}),
+          ...(availabilityCommitGuard ? {
+            availabilityCommitGuard,
+            availabilityCommitTargetGuard
+          } : {})
         } : undefined);
+        products = await this.removeBookingProductsOutsideStartDate(booking.start_date);
+        guardedCommitPublished = hasCommitGuard;
         const addedLines = products.filter(line => sameAvailabilityId(line.product_id ?? line.id, refreshedCandidate.productId) && line.metadata?.availability_candidate_key === refreshedCandidate.key && !beforeProductLineUids.has(getProductLineUid(line)));
         productLineUids = addedLines.map(line => getProductLineUid(line)).filter(Boolean);
-        const addedBookings = (this.getTempOrder()?.bookings || []).filter(item => item.metadata?.availability_candidate_key === refreshedCandidate.key && !beforeBookingUids.has(getBookingUid(item)));
+        const addedBookings = ((hasCommitGuard ? rememberedOrder : this.getTempOrder())?.bookings || []).filter(item => item.metadata?.availability_candidate_key === refreshedCandidate.key && !beforeBookingUids.has(getBookingUid(item)));
         bookingUids = addedBookings.map(item => getBookingUid(item)).filter(Boolean);
         if (bookingUids.length === 0) {
           bookingUids = addedLines.map(line => String(line.booking_uid ?? line.metadata?.booking_uid ?? '')).filter(Boolean);
@@ -3467,12 +3944,13 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         productLineUid = productLineUids[productLineUids.length - 1] || '';
         bookingUid = bookingUids[bookingUids.length - 1] || '';
       }
-      this.invalidateAvailabilityContextsAfterCommit();
-      const nextContext = this.getAvailabilityContextEntry(normalizedContextId);
+      const targetStillCurrent = !hasCommitGuard || availabilityCommitTargetGuard();
+      if (targetStillCurrent) this.invalidateAvailabilityContextsAfterCommit();else this.removeAvailabilityContext(normalizedContextId);
+      const nextContext = hasCommitGuard ? this.availabilityContextRegistry.get(normalizedContextId) : this.getAvailabilityContextEntry(normalizedContextId);
       const result = {
         contextId: normalizedContextId,
-        contextVersion: nextContext.activeVersion,
-        tempOrder: this.getTempOrder(),
+        contextVersion: nextContext?.activeVersion ?? refreshedCandidate.availabilityContextVersion,
+        tempOrder: hasCommitGuard ? rememberedOrder : this.getTempOrder(),
         validation,
         candidate: refreshedCandidate,
         productLineUid,
@@ -3480,10 +3958,19 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         productLineUids,
         bookingUids
       };
-      await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onAvailabilitySelectionCommitted}`, result);
+      if (targetStillCurrent) {
+        // A notification failure after publication must not invite a duplicate add.
+        const emit = () => this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onAvailabilitySelectionCommitted}`, result);
+        if (guardedCommitPublished) {
+          try {
+            await emit();
+          } catch {/* The cart mutation has already succeeded. */}
+        } else await emit();
+      }
       return result;
     } finally {
-      await this.releaseAvailabilityCommitLock(normalizedContextId);
+      const release = this.releaseAvailabilityCommitLock(normalizedContextId);
+      if (guardedCommitPublished) await release.catch(() => undefined);else await release;
     }
   }
 }