@pisell/pisellos 2.2.314 → 2.2.316

package/lib/modules/Payment/index.js

@@ -9,6 +9,7 @@ var _exportNames = {
 };
 exports.PaymentModule = void 0;
 exports.generateRequestUniqueId = generateRequestUniqueId;
+var _loadPaymentMethods = require("../../shared/payment/loadPaymentMethods");
 var _BaseModule = require("../BaseModule");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
@@ -282,12 +283,10 @@ class PaymentModule extends _BaseModule.BaseModule {
   async getPayMethodListAsync() {
     this.logInfo('Starting getPayMethodListAsync');
     try {
-      const response = await this.request.get('/pay/custom-payment/all', {
+      const payMethods = await (0, _loadPaymentMethods.loadPaymentMethods)(this.request, {
+        transport: 'os-server',
         filterPaymentMethods: true
-      }, {
-        osServer: true
       });
-      const payMethods = response?.data || response || [];
       this.logInfo('getPayMethodListAsync completed successfully', {
         payMethods
       });

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

@@ -218,6 +218,17 @@ export interface ProductData {
     bundle?: any[];
     /** 商品选项组成 */
     options?: any[];
+    /** 单规格组；用于由已选 option 反查规格项名称、价格等商品快照字段。 */
+    option_group?: Array<{
+        id: number | string;
+        option_item?: Array<{
+            id: number | string;
+            name?: string | Record<string, any>;
+            title?: string | Record<string, any>;
+            [key: string]: any;
+        }>;
+        [key: string]: any;
+    }>;
     /** 商品原信息 */
     origin?: any;
     /** 容量 */

package/lib/modules/ProductList/index.js

@@ -125,7 +125,7 @@ class ProductList extends _BaseModule.BaseModule {
       online_store: 'online-store',
       scan_to_order: 'online-store',
       'scan-to-order': 'online-store',
-      scan_to_order_2: 'mobile_order',
+      scan_to_order_2: 'online-store',
       scan_to_order_3: 'scantoorder3'
     };
     const rawApplicationCode = this.otherParams?.channel;

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;

package/lib/modules/ResourcePlanner/planner.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createAvailabilityProjection = createAvailabilityProjection;
+exports.getDurationBusinessDate = getDurationBusinessDate;
 exports.getProductTimeRanges = getProductTimeRanges;
 exports.queryAvailabilityProjection = queryAvailabilityProjection;
 exports.validateAvailabilitySelection = validateAvailabilitySelection;
@@ -162,7 +163,11 @@ function resolveCutOffPolicyIssue(policy) {
   return null;
 }
 function addLeadWindow(base, unit, unitType, _timezoneName) {
-  if (unitType === 'days') return (0, _localClock.addLocalCalendarDays)(base, unit);
+  if (unitType === 'days') {
+    const leadDate = (0, _localClock.addLocalCalendarDays)(base, unit);
+    // Positive day lead times start at midnight; zero days keeps the current-time boundary.
+    return Math.trunc(unit) > 0 ? (0, _localClock.localDateToScalarStart)((0, _localClock.formatLocalDate)(leadDate)) : leadDate;
+  }
   if (unitType === 'hours') return (0, _localClock.addLocalHours)(base, unit);
   return (0, _localClock.addLocalMinutes)(base, unit);
 }
@@ -250,6 +255,18 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   const policy = product.cutOffPolicy;
+  // Current duration items can be shown outside business hours. Their real
+  // interval must remain unavailable, including products with no resource groups.
+  if (evaluationContext.useDurationTimeGrid && product.kind === 'duration' && !projection.meta.defaults.operatingHours.windows.some(window => {
+    const range = normalizeAbsoluteRange(window);
+    return range && contains(range, candidateRange);
+  })) {
+    return {
+      status: 'unavailable',
+      reasonCodes: ['outside_operating_hours'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
   if (!policy) return null;
   if (resolveCutOffPolicyIssue(policy)) {
     return {
@@ -286,8 +303,8 @@ function evaluateCandidateTimeGate(params) {
     // otherwise a minute refresh turns it into 0 capacity and incorrectly
     // advances a create flow to the next slot. The earlier `past` gate still
     // rejects the anchor once its booking range has ended.
-    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
-    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
+    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && !evaluationContext.enforceSaleCutoff && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
+    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useDurationTimeGrid || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
     const hasNotReachedStart = isActivePosDurationAnchor || (usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start);
     if (hasNotReachedStart) return null;
     return {
@@ -489,11 +506,34 @@ function normalizeOperatingHours(params) {
   }));
   const windows = normalizeWindows(sourceWindows);
   const excludedWindows = normalizeWindows(params.input?.excludedWindows || []);
+  // Keep original dates and opening anchors separately: the availability
+  // windows below may be clipped at midnight or merged without segment identity.
+  const periodMap = new Map();
+  const originalPeriods = params.input?.businessPeriods || [...sourceWindows, ...(params.input?.excludedWindows || [])].map(window => ({
+    businessDate: window.businessDate || window.startAt.slice(0, 10),
+    startAt: window.openingAnchorAt || window.startAt,
+    endAt: window.endAt
+  }));
+  originalPeriods.forEach(period => {
+    const range = normalizeAbsoluteRange(period);
+    if (!range) return;
+    const previous = periodMap.get(period.businessDate);
+    periodMap.set(period.businessDate, {
+      start: previous ? Math.min(previous.start, range.start) : range.start,
+      end: previous ? Math.max(previous.end, range.end) : range.end
+    });
+  });
+  const businessPeriods = Array.from(periodMap, ([businessDate, range]) => ({
+    businessDate,
+    startAt: formatDateTime(range.start, params.timezoneName, params.fixedOffsetMinutes),
+    endAt: formatDateTime(range.end, params.timezoneName, params.fixedOffsetMinutes)
+  })).sort((left, right) => left.startAt.localeCompare(right.startAt));
   return {
     source: params.input?.source || params.fallbackSource,
     scheduleIds: uniqById(params.input?.scheduleIds || []),
     missingScheduleIds: uniqById(params.input?.missingScheduleIds || []),
     windows,
+    businessPeriods,
     ...(excludedWindows.length > 0 ? {
       excludedWindows
     } : {})
@@ -992,6 +1032,162 @@ function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection,
     scheduleRefs: []
   };
 }
+
+/** Resolve the label without changing the real calendar timestamp. */
+function getDurationBusinessDate(projection, startAt) {
+  const start = toDateTime(startAt);
+  const periods = projection.meta.defaults.operatingHours.businessPeriods || [];
+  const period = [...periods].reverse().find(item => {
+    const range = normalizeAbsoluteRange(item);
+    return range && range.start <= start && start < range.end;
+  });
+  return period?.businessDate || startAt.slice(0, 10);
+}
+function getAlignedDurationRanges(params) {
+  const {
+    projection,
+    product,
+    request,
+    runtimeOptions,
+    dateRange,
+    operatingRanges,
+    baseRanges,
+    resourceWindowIndex,
+    fixedOffsetMinutes
+  } = params;
+  const step = projection.meta.defaults.slotStepMinutes;
+  const now = floorToMinute(toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt));
+  if (!Number.isFinite(now)) throw availabilityError('INVALID_TARGET_FILTER', 'evaluatedAt 必须是有效时间');
+  const nowAt = formatDateTime(now, projection.meta.timezone, fixedOffsetMinutes);
+  const currentBusinessDate = getDurationBusinessDate(projection, nowAt);
+  const inRequestedDays = date => date >= dateRange.startDate && date <= dateRange.endDate;
+  const periods = (projection.meta.defaults.operatingHours.businessPeriods || []).filter(period => inRequestedDays(period.businessDate));
+  // A prepared month includes tomorrow's windows too; the single-day UI must
+  // receive the selected business cycle's end, not tomorrow's closing time.
+  const operatingEndAt = dateRange.startDate === dateRange.endDate && periods.length ? periods.reduce((latest, period) => period.endAt > latest ? period.endAt : latest, periods[0].endAt) : undefined;
+  const ranges = [];
+  const duration = resolveRequestedDurationMinutes(product, request);
+  const addRange = (start, end, businessDate) => {
+    if (end <= start) return;
+    const candidate = createDurationTimeRangeWithEnd(product, start, end, projection, fixedOffsetMinutes);
+    candidate.businessDate = businessDate || getDurationBusinessDate(projection, candidate.startAt);
+    if (inRequestedDays(candidate.businessDate)) ranges.push(candidate);
+  };
+  // A flexible end comes from resources that actually cover this exact start,
+  // never from the next future window. Keep alternative real ends separate.
+  const flexibleEnds = start => {
+    const operating = operatingRanges.find(range => range.start <= start && start < range.end);
+    if (!operating) return [];
+    const businessDate = getDurationBusinessDate(projection, formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes));
+    const period = projection.meta.defaults.operatingHours.businessPeriods?.find(item => item.businessDate === businessDate);
+    const operatingEnd = Math.min(operating.end, period ? toDateTime(period.endAt) : operating.end);
+    const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false);
+    const groups = requiredGroups.map(group => projection.resources.filter(resource => matchesRequirementGroup(group, resource, product, request.partySize)).filter(resource => !request.resourceIds?.length || request.resourceIds.some(id => sameId(id, resource.id))).flatMap(resource => (resourceWindowIndex.get(String(resource.id)) || []).filter(range => range.start <= start && start < range.end).map(range => Math.min(range.end, operatingEnd))));
+    if (groups.some(ends => ends.length === 0)) return [];
+    if (!groups.length) return [operatingEnd];
+    return Array.from(new Set(groups.flat())).filter(end => groups.every(ends => ends.some(availableEnd => availableEnd >= end))).sort((left, right) => left - right);
+  };
+  if (product.isFlexibleDuration) {
+    // Preserve the existing continuous-window UI, with the business-day label.
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      baseRanges.forEach(range => {
+        const start = Math.max(range.start, periodRange.start, now);
+        const end = Math.min(range.end, periodRange.end);
+        if (start < end) addRange(start, end, period.businessDate);
+      });
+    });
+  } else {
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      const anchor = 60 % step === 0 ? toDateStart(period.businessDate) : periodRange.start;
+      baseRanges.forEach(range => {
+        const lower = Math.max(range.start, periodRange.start, now);
+        const upper = Math.min(range.end, periodRange.end);
+        let cursor = anchor + Math.ceil((lower - anchor) / (step * 60000)) * step * 60000;
+        for (; cursor + duration * 60000 <= upper; cursor += step * 60000) {
+          addRange(cursor, cursor + duration * 60000, period.businessDate);
+        }
+      });
+    });
+  }
+  let unavailableCurrentTime;
+  if (inRequestedDays(currentBusinessDate)) {
+    if (product.isFlexibleDuration) {
+      const ends = flexibleEnds(now);
+      ends.forEach(end => addRange(now, end, currentBusinessDate));
+      if (!ends.length) {
+        unavailableCurrentTime = {
+          productId: product.id,
+          startAt: nowAt,
+          date: formatDate(now),
+          businessDate: currentBusinessDate,
+          startTime: formatTime(now),
+          status: 'unavailable',
+          reasonCodes: [operatingRanges.some(range => range.start <= now && now < range.end) ? 'outside_resource_window' : 'outside_operating_hours']
+        };
+      }
+    } else {
+      // Even outside a working window the fixed product has a real end. Query
+      // reports unavailable; POS manual capabilities remain a separate policy.
+      addRange(now, now + duration * 60000, currentBusinessDate);
+    }
+  }
+  const rememberedAt = request.rememberedStartAtByProductId?.[String(product.id)];
+  if (rememberedAt !== undefined) {
+    const start = toDateTime(rememberedAt);
+    if (!Number.isFinite(start)) throw availabilityError('INVALID_TARGET_FILTER', '记忆开始时间必须是完整日期时间');
+    if (product.isFlexibleDuration) {
+      flexibleEnds(start).forEach(end => addRange(start, end));
+    } else {
+      addRange(start, start + duration * 60000);
+    }
+  }
+  const editingAt = request.editingStartAtByProductId?.[String(product.id)];
+  if (editingAt !== undefined) {
+    const start = toDateTime(editingAt);
+    const editingDuration = Number(request.durationMinutesByProductId?.[String(product.id)]);
+    if (!Number.isFinite(start) || !Number.isInteger(editingDuration) || editingDuration <= 0) {
+      throw availabilityError('INVALID_TARGET_FILTER', '编辑时间必须包含完整开始日期时间和明确的正整数时长');
+    }
+    // Editing restores the original interval, including its actual overnight
+    // date. It neither adopts the current grid nor recomputes a flexible end.
+    if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+      addRange(start, addMinutesZoned(start, editingDuration, projection.meta.timezone));
+    }
+  }
+
+  // Explicit custom input keeps its existing start + requested duration
+  // semantics. Remembered input above must never use this default-30 path.
+  if (dateRange.startDate === dateRange.endDate) {
+    resolveRequestedDurationStartTimes(product, request).forEach(startTime => {
+      const sameDayStart = toDateTimeInDate(dateRange.startDate, startTime);
+      const period = periods.find(item => item.businessDate === dateRange.startDate);
+      const periodRange = period ? normalizeAbsoluteRange(period) : null;
+      const nextDayStart = (0, _localClock.addLocalCalendarDays)(sameDayStart, 1);
+      // HH:mm is entered within a selected business day, whose early hours
+      // may belong to the next calendar day. Do not move other out-of-hours
+      // manual input to tomorrow merely because the business closes overnight.
+      const start = periodRange && !(periodRange.start <= sameDayStart && sameDayStart < periodRange.end) && periodRange.start <= nextDayStart && nextDayStart < periodRange.end ? nextDayStart : sameDayStart;
+      if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+        addRange(start, start + duration * 60000);
+      }
+    });
+  }
+  return {
+    productId: product.id,
+    title: product.title,
+    kind: product.kind,
+    slotStepMinutes: step,
+    ...(operatingEndAt ? {
+      operatingEndAt
+    } : {}),
+    ranges: dedupeProductRanges(ranges),
+    ...(unavailableCurrentTime ? {
+      unavailableCurrentTime
+    } : {})
+  };
+}
 function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
   const normalizedPartySize = normalizePartySize(request.partySize);
   const dateRange = resolveProjectionDateRange(projection, request.dateRange);
@@ -1044,6 +1240,19 @@ function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
       includeExcludedWindows: allowExcludedScheduleDateOverride
     })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
     const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
+    if (runtimeOptions.useDurationTimeGrid) {
+      return getAlignedDurationRanges({
+        projection,
+        product,
+        request,
+        runtimeOptions,
+        dateRange,
+        operatingRanges,
+        baseRanges,
+        resourceWindowIndex,
+        fixedOffsetMinutes
+      });
+    }
     const durationMinutes = resolveRequestedDurationMinutes(product, request);
     const flexibleStartAt = (() => {
       if (!product.isFlexibleDuration) return undefined;
@@ -1265,7 +1474,9 @@ function buildEvaluationContext(params) {
     selectionsByGroupKey,
     useExactDurationCandidateMinute: params.useExactDurationCandidateMinute === true,
     durationCandidateAnchorAtMs: Number.isFinite(durationCandidateAnchorAt) ? floorToMinute(durationCandidateAnchorAt) : null,
-    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true
+    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true,
+    useDurationTimeGrid: params.useDurationTimeGrid === true,
+    enforceSaleCutoff: params.enforceSaleCutoff === true
   };
 }
 function summarizeStatuses(statuses) {
@@ -1672,6 +1883,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     projection,
     evaluatedAt,
     resourceIds: request.resourceIds,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1748,6 +1961,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     partySize: normalizedPartySize
   }, {
     evaluatedAt,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1772,7 +1987,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
           candidateRangeCache,
           evaluationContext
         });
-        const aggregate = byDate.get(candidate.date) || {
+        const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+        const aggregate = byDate.get(candidateDate) || {
           availableCount: 0,
           totalCount: 0,
           maxPartySize: 0,
@@ -1790,8 +2006,24 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
         aggregate.maxCapacity += evaluated.maxCapacity;
         pushStatusAggregate(aggregate.statusAggregate, evaluated.status);
         evaluated.reasonCodes.forEach(reasonCode => aggregate.reasonCodeSet.add(reasonCode));
-        byDate.set(candidate.date, aggregate);
+        byDate.set(candidateDate, aggregate);
       });
+      if (group.unavailableCurrentTime) {
+        const current = group.unavailableCurrentTime;
+        const aggregate = byDate.get(current.businessDate) || {
+          availableCount: 0,
+          totalCount: 0,
+          maxPartySize: 0,
+          remainingCapacity: 0,
+          maxCapacity: 0,
+          reasonCodeSet: new Set(),
+          statusAggregate: createStatusAggregate()
+        };
+        aggregate.totalCount += 1;
+        pushStatusAggregate(aggregate.statusAggregate, 'unavailable');
+        current.reasonCodes.forEach(reason => aggregate.reasonCodeSet.add(reason));
+        byDate.set(current.businessDate, aggregate);
+      }
       const dates = enumerateDates(dateRange.startDate, dateRange.endDate).map(date => {
         const aggregate = byDate.get(date);
         return {
@@ -1849,10 +2081,20 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
       maxPartySize = Math.max(maxPartySize, evaluated.maxPartySize);
       pushStatusAggregate(productStatusAggregate, evaluated.status);
       evaluated.reasonCodes.forEach(reasonCode => productReasonCodeSet.add(reasonCode));
-      const dateAggregate = dateStatusMap.get(candidate.date) || createStatusAggregate();
+      const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+      const dateAggregate = dateStatusMap.get(candidateDate) || createStatusAggregate();
       pushStatusAggregate(dateAggregate, evaluated.status);
-      dateStatusMap.set(candidate.date, dateAggregate);
+      dateStatusMap.set(candidateDate, dateAggregate);
     });
+    if (group.unavailableCurrentTime) {
+      const current = group.unavailableCurrentTime;
+      totalTimeCount += 1;
+      pushStatusAggregate(productStatusAggregate, 'unavailable');
+      current.reasonCodes.forEach(reason => productReasonCodeSet.add(reason));
+      const dateAggregate = dateStatusMap.get(current.businessDate) || createStatusAggregate();
+      pushStatusAggregate(dateAggregate, 'unavailable');
+      dateStatusMap.set(current.businessDate, dateAggregate);
+    }
     const availableDateCount = Array.from(dateStatusMap.values()).filter(aggregate => {
       const status = summarizeStatusAggregate(aggregate);
       return status === 'available' || status === 'limited';
@@ -1921,6 +2163,8 @@ function validateAvailabilitySelection(projection, params, runtimeOptions = {})
       projection,
       evaluatedAt,
       requirementSelections: params.requirementSelections,
+      useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+      enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
       useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
       allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
     })

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

@@ -92,6 +92,9 @@ export interface AvailabilityProduct {
     raw?: Record<string, any>;
 }
 export interface AvailabilityResourceWindow extends AvailabilityAbsoluteRange {
+    /** Original business day and opening anchor, before coverage clipping. */
+    businessDate?: string;
+    openingAnchorAt?: string;
     source?: string;
     raw?: Record<string, any>;
 }
@@ -101,10 +104,15 @@ export interface AvailabilityOperatingHoursSnapshot {
     scheduleIds: AvailabilityId[];
     missingScheduleIds: AvailabilityId[];
     windows: AvailabilityResourceWindow[];
+    /** Complete business cycles; lunch gaps remain in windows, not in this envelope. */
+    businessPeriods?: AvailabilityBusinessPeriod[];
     /** Schedule windows omitted only because their date is excluded. POS may use
      * these to surface an unavailable, manually selectable candidate. */
     excludedWindows?: AvailabilityResourceWindow[];
 }
+export interface AvailabilityBusinessPeriod extends AvailabilityAbsoluteRange {
+    businessDate: string;
+}
 export interface AvailabilityResource {
     id: AvailabilityId;
     formId?: AvailabilityId;
@@ -212,6 +220,17 @@ export interface ProductTimeRange extends AvailabilityDisplayRange {
     bookingEndAt: string;
     scheduleRefs: AvailabilityScheduleRef[];
     primaryScheduleRef?: AvailabilityScheduleRef;
+    /** Business-day label. date/startAt keep the actual calendar date. */
+    businessDate?: string;
+}
+export interface UnavailableCurrentTime {
+    productId: AvailabilityId;
+    startAt: string;
+    date: string;
+    businessDate: string;
+    startTime: string;
+    status: 'unavailable';
+    reasonCodes: string[];
 }
 export interface ProductTimeRangeGroup {
     productId: AvailabilityId;
@@ -221,6 +240,8 @@ export interface ProductTimeRangeGroup {
     /** 单日查询对应营业窗口的最终结束时刻，不受资源排班是否为空影响。 */
     operatingEndAt?: string;
     ranges: ProductTimeRange[];
+    /** A display-only current item when flexible duration has no valid end. Never submit it. */
+    unavailableCurrentTime?: UnavailableCurrentTime;
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
     productId: AvailabilityId;
@@ -242,6 +263,10 @@ export interface GetProductTimeRangesRequest {
     partySize?: number;
     durationMinutesByProductId?: Record<string, number>;
     durationStartTimesByProductId?: Record<string, string[]>;
+    /** Restore only the exact remembered start; recompute the end from current product/windows. */
+    rememberedStartAtByProductId?: Record<string, string>;
+    /** Edit only: preserve the full actual start plus an explicit durationMinutesByProductId. */
+    editingStartAtByProductId?: Record<string, string>;
     /**
      * POS 手工输入时间的兼容开关：只为明确请求的 start time 补候选，
      * 不改变常规候选列表仍按营业时间生成的规则。
@@ -250,6 +275,10 @@ export interface GetProductTimeRangesRequest {
 }
 export interface GetProductTimeRangesRuntimeOptions {
     evaluatedAt?: string;
+    /** Enabled by the POS/Kiosk facade only; other consumers retain their existing grid. */
+    useDurationTimeGrid?: boolean;
+    /** Automatic remembered selection must not use POS opening-minute cutoff exceptions. */
+    enforceSaleCutoff?: boolean;
     /**
      * Internal POS capability: fixed-duration candidates start from the stable
      * context anchor's current minute instead of rounding up to ten minutes, and

package/lib/modules/Rules/index.js

@@ -8,6 +8,7 @@ var _BaseModule = require("../BaseModule");
 var _types = require("./types");
 var _utils = require("../../solution/ShopDiscount/utils");
 var _utils2 = require("../Cart/utils");
+var _utils3 = require("../Holder/utils");
 var _decimal = _interopRequireDefault(require("decimal.js"));
 var _lodashEs = require("lodash-es");
 var _dayjs = _interopRequireDefault(require("dayjs"));
@@ -59,7 +60,7 @@ class RulesModule extends _BaseModule.BaseModule {
     if (discount.holder?.holder_type !== 'form') return true;
 
     // getProduct 会裁剪商品字段，从原始商品读取配置，套餐子项沿用父商品。
-    const holderConfig = holderSource?.holder_config ?? holderSource?.metadata?.holder_config ?? holderSource?.origin?.holder_config ?? holderSource?.metadata?.origin?.holder_config ?? holderSource?._origin?.holder_config ?? holderSource?._extend?.holder_config ?? holderSource?._extend?.product?.holder_config ?? holderSource?._extend?.product?.metadata?.holder_config;
+    const holderConfig = (0, _utils3.resolveProductHolderConfig)(holderSource);
     const holderStatus = holderConfig?.status;
     const holderEnabled = holderStatus === true || ['enable', '1'].includes(String(holderStatus).trim().toLowerCase());
     if (!holderEnabled || holderConfig?.resource_id === undefined || holderConfig?.resource_id === null || holderConfig?.resource_id === '') {

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

@@ -10,6 +10,10 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     private openCache;
     private fatherModule;
     private hasLoadedScheduleList;
+    private scheduleListPromise;
+    private scheduleListRequestVersion;
+    private scheduleCatalogScope;
+    private otherParams;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     /**
@@ -19,6 +23,9 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
      * scheduleModule.updateOtherParams({ openCache: true, cacheId: 'cache-2' });
      */
     updateOtherParams(params: Record<string, any>): void;
+    private syncScheduleCatalogScope;
+    private resetScheduleCatalog;
+    destroy(): void;
     /**
      * 加载当前店铺下所有 schedule
      *
@@ -27,6 +34,7 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     loadAllSchedule(options?: {
         useCache?: boolean;
     }): Promise<void>;
+    private loadScheduleCatalog;
     setScheduleList(list: ScheduleItem[]): void;
     private syncScheduleMap;
     getScheduleList(): ScheduleItem[];