@pisell/pisellos 2.3.144 → 2.3.146

package/lib/solution/UnifiedBookingSales/index.js

@@ -33,6 +33,7 @@ var _dayjs = _interopRequireDefault(require("dayjs"));
 var _lodashEs = require("lodash-es");
 var _modules = require("../../modules");
 var _utils = require("../../modules/BookingContext/utils");
+var _cacheItemToBookingInput = require("../../modules/BookingContext/utils/cacheItemToBookingInput");
 var _OpenData = require("../../modules/OpenData");
 var _getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
 var _ResourcePlanner = require("../../modules/ResourcePlanner");
@@ -1306,6 +1307,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();
@@ -1509,8 +1530,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) {
@@ -2413,7 +2441,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 {
@@ -2437,7 +2467,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 => {
@@ -2451,12 +2482,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],
@@ -2846,24 +2888,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,
@@ -2899,7 +2951,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       resourceOccupancies: [...remoteOccupancies, ...cartOccupancies],
       mode,
       timezone: timezoneLabel,
-      coverage: dateRange,
+      coverage: coverageDateRange,
       slotStepMinutes,
       businessHours,
       operatingHours,
@@ -3154,14 +3206,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
@@ -3180,7 +3265,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
     });
@@ -3269,6 +3360,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);
@@ -3374,6 +3484,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,
@@ -3419,17 +3533,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]
@@ -3440,6 +3569,9 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
           } : {})
         } : {})
       }, {
+        evaluatedAt: this.getAvailabilityRuntimeDateTime(),
+        useDurationTimeGrid: this.usesDurationTimeGrid(refreshedProjection),
+        enforceSaleCutoff: isRememberedSelection,
         useExactDurationCandidateMinute: allowPosAvailabilityOverride,
         allowSessionCustomRanges: allowPosAvailabilityOverride,
         allowExcludedScheduleDateOverride: allowPosAvailabilityOverride
@@ -3464,6 +3596,8 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
         partySize,
         bookingCount
       }, {
+        useDurationTimeGrid: this.usesDurationTimeGrid(refreshedProjection),
+        enforceSaleCutoff: isRememberedSelection,
         useExactDurationCandidateMinute: allowPosAvailabilityOverride,
         allowExcludedScheduleDateOverride: allowPosAvailabilityOverride
       });
@@ -3524,6 +3658,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) {
@@ -3541,6 +3699,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,
@@ -3593,12 +3768,20 @@ 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?.();
+        const products = await this.addProductToOrder(transformed, booking, params.salesNotes?.length || availabilityCommitGuard ? {
+          ...(params.salesNotes?.length ? {
+            salesNotes: params.salesNotes
+          } : {}),
+          ...(availabilityCommitGuard ? {
+            availabilityCommitGuard,
+            availabilityCommitTargetGuard
+          } : {})
         } : undefined);
+        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);
@@ -3606,12 +3789,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,
@@ -3619,10 +3803,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;
     }
   }
 }

package/lib/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/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "2.3.144",
+  "version": "2.3.146",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",