@pisell/pisellos 2.2.292 → 2.2.293

package/lib/solution/UnifiedBookingSales/index.js

@@ -5,26 +5,36 @@ Object.defineProperty(exports, "__esModule", {
 });
 var _exportNames = {
   buildPlannerDiscountResult: true,
-  normalizeProductForPlanner: true,
-  buildPlannerResourcesFromV2: true,
-  collectPlannerResourceIds: true,
-  buildBookingFromAssignment: true,
-  buildBookingFromAssignments: true,
-  buildPlannerLineIdentity: true,
+  normalizeProductForAvailability: true,
+  buildAvailabilityResourcesFromV2: true,
+  collectAvailabilityResourceIds: true,
+  buildAvailabilityLineIdentity: true,
+  buildBookingFromAvailabilityAssignment: true,
+  buildBookingFromAvailabilityAssignments: true,
   UnifiedBookingSalesImpl: true,
-  UnifiedBookingSales: true
+  UnifiedBookingSales: true,
+  AvailabilityError: true
 };
+Object.defineProperty(exports, "AvailabilityError", {
+  enumerable: true,
+  get: function () {
+    return _ResourcePlanner.AvailabilityError;
+  }
+});
 exports.UnifiedBookingSalesImpl = exports.UnifiedBookingSales = void 0;
-exports.buildBookingFromAssignment = buildBookingFromAssignment;
-exports.buildBookingFromAssignments = buildBookingFromAssignments;
+exports.buildAvailabilityLineIdentity = buildAvailabilityLineIdentity;
+exports.buildAvailabilityResourcesFromV2 = buildAvailabilityResourcesFromV2;
+exports.buildBookingFromAvailabilityAssignment = buildBookingFromAvailabilityAssignment;
+exports.buildBookingFromAvailabilityAssignments = buildBookingFromAvailabilityAssignments;
 exports.buildPlannerDiscountResult = buildPlannerDiscountResult;
-exports.buildPlannerLineIdentity = buildPlannerLineIdentity;
-exports.buildPlannerResourcesFromV2 = buildPlannerResourcesFromV2;
-exports.collectPlannerResourceIds = collectPlannerResourceIds;
-exports.normalizeProductForPlanner = normalizeProductForPlanner;
+exports.collectAvailabilityResourceIds = collectAvailabilityResourceIds;
+exports.normalizeProductForAvailability = normalizeProductForAvailability;
 var _dayjs = _interopRequireDefault(require("dayjs"));
+var _lodashEs = require("lodash-es");
 var _modules = require("../../modules");
+var _utils = require("../../modules/BookingContext/utils");
 var _getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
+var _ResourcePlanner = require("../../modules/ResourcePlanner");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -37,12 +47,59 @@ Object.keys(_types).forEach(function (key) {
     }
   });
 });
+var _remoteOccupancyCache = require("./remoteOccupancyCache");
 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 }; }
-// import { BaseSalesImpl } from '../BaseSales';
-
-const OPEN_DATA_SECTION_CODES = ['sale', 'reservation', 'fulfillment', 'menu', 'workflow'];
+const OPEN_DATA_SECTION_CODES = ['sale', 'reservation', 'fulfillment', 'menu', 'workflow', '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;
+  return normalized;
+}
+function getCandidateDurationMinutes(candidate) {
+  const startAt = candidate.bookingStartAt || candidate.startAt;
+  const endAt = candidate.bookingEndAt || candidate.endAt;
+  try {
+    const start = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(startAt));
+    const end = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(endAt));
+    const minutes = Math.round((end - start) / 60000);
+    return Number.isInteger(minutes) && minutes > 0 ? minutes : undefined;
+  } catch (_error) {
+    return undefined;
+  }
+}
+function getCandidateStartTime(candidate) {
+  if (/^([01]\d|2[0-3]):[0-5]\d$/.test(candidate.startTime || '')) {
+    return candidate.startTime;
+  }
+  const startAt = candidate.bookingStartAt || candidate.startAt;
+  try {
+    const start = (0, _localClock.parseLocalDateTime)(startAt);
+    return `${String(start.hour).padStart(2, '0')}:${String(start.minute).padStart(2, '0')}`;
+  } catch (_error) {
+    return undefined;
+  }
+}
+function normalizePositiveIntegerList(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(new Set(value.map(item => normalizePositiveInteger(item)).filter(item => item !== undefined)));
+}
+function toConfiguredBoolean(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'number') return value !== 0;
+  if (typeof value === 'string') {
+    return ['1', 'true', 'yes', 'y', 'on'].includes(value.trim().toLowerCase());
+  }
+  return false;
+}
+function normalizeItemRuleStrategyConfigs(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(config => Boolean(config && typeof config === 'object' && config.metadata?.type === 'item_rule'));
+}
 function isRecord(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -149,82 +206,477 @@ function filterCustomerBoundDiscounts(discountList) {
   if (!Array.isArray(discountList)) return [];
   return discountList.filter(discount => !isCustomerBoundDiscount(discount));
 }
-
-/** Maps several legacy product shapes into the Planner's small, stable vocabulary. */
+const DEFAULT_AVAILABILITY_SLOT_STEP_MINUTES = 30;
+const DEFAULT_AVAILABILITY_BUSINESS_HOURS = {
+  // Same start/end is interpreted as an overnight range, i.e. 24 hours.
+  startTime: '00:00',
+  endTime: '00:00'
+};
+const MAX_AVAILABILITY_RANGE_DAYS = 90;
+const MAX_AVAILABILITY_CONTEXT_REGISTRY = 128;
+const MAX_AVAILABILITY_PROJECTION_POOL = 16;
+const MAX_REMOTE_OCCUPANCY_RESOURCE_DATE_CELLS = 4096;
+function isValidClockTime(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return false;
+  return Number(match[1]) < 24 && Number(match[2]) < 60;
+}
+function assertValidAvailabilityTimezone(timezoneName) {
+  if (!String(timezoneName || '').trim()) {
+    throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'timezone label 不能为空', {
+      timezone: timezoneName
+    });
+  }
+}
+function normalizeAvailabilityLocalDateTime(value, fixedOffsetMinutes) {
+  if (value == null || value === '') return null;
+  try {
+    const localText = typeof value?.format === 'function' ? value.format('YYYY-MM-DDTHH:mm:ss') : String(value);
+    return (0, _localClock.formatLocalDateTime)((0, _localClock.parseLocalDateTime)(localText), fixedOffsetMinutes);
+  } catch {
+    return null;
+  }
+}
+function normalizeAvailabilityLocalDateTimeRange(params) {
+  const startText = normalizeAvailabilityLocalDateTime(params.startAt, params.fixedOffsetMinutes);
+  const endText = normalizeAvailabilityLocalDateTime(params.endAt, params.fixedOffsetMinutes);
+  if (!startText || !endText) return null;
+  const startScalar = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(startText));
+  let endScalar = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(endText));
+  if (endScalar <= startScalar && params.rollOverEnd) {
+    endScalar = (0, _localClock.addLocalCalendarDays)(endScalar, 1);
+  }
+  if (endScalar <= startScalar) return null;
+  return {
+    startAt: startText,
+    endAt: (0, _localClock.formatLocalDateTime)(endScalar, params.fixedOffsetMinutes),
+    startScalar,
+    endScalar
+  };
+}
+function sameAvailabilityId(left, right) {
+  return left !== undefined && left !== null && right !== undefined && right !== null && String(left) === String(right);
+}
+function uniqueAvailabilityIds(values) {
+  const result = new Map();
+  values.forEach(value => {
+    const id = toNumberId(value);
+    if (id !== undefined) result.set(String(id), id);
+  });
+  return Array.from(result.values());
+}
+function assertAvailabilityCatalogProductIds(productIds, context) {
+  if (productIds == null) return;
+  if (!Array.isArray(productIds)) {
+    throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', `${context} 必须是 number[]`, {
+      context,
+      productIds
+    });
+  }
+  const invalidIds = productIds.filter(id => typeof id !== 'number' || !Number.isFinite(id));
+  if (invalidIds.length > 0) {
+    throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', `${context} 只能包含有限数值商品 ID`, {
+      context,
+      invalidIds,
+      productIds
+    });
+  }
+}
+function normalizeResourceType(_value) {
+  // 当前业务只支持每个资源组选择一个具体资源。
+  // 保留公共联合类型以兼容已有调用方，但暂不启用 multiple/capacity 分支。
+  return 'single';
+}
 function resolveProductKind(product) {
-  if (product.duration) return 'duration';
+  if (product.duration || product.service_duration) return 'duration';
+  if (product.extension_type === 'venue_slot') return 'venue_slot';
   if (['session_product', 'session_ticket'].includes(product.extension_type)) return 'session';
-  if (product.cartDetailValue?.session || product._extend?.other?.session) return 'session';
-  if (Array.isArray(product['schedule.ids']) && product['schedule.ids'].length > 0) return 'session';
+  if (product.cartDetailValue?.session || product._extend?.other?.session || product.session) {
+    return 'session';
+  }
+  const scheduleIds = product['schedule.ids'] || product.schedule_ids;
+  if (Array.isArray(scheduleIds) && scheduleIds.length > 0) return 'session';
   return 'normal';
 }
-function normalizeSchedule(product) {
-  const session = product.cartDetailValue?.session || product._extend?.other?.session || product.session;
-  if (session?.start_at && session?.end_at) {
-    return [{
-      start_at: session.start_at,
-      end_at: session.end_at
-    }];
-  }
-  const schedules = product.schedules || product.schedule || product._schedule;
-  if (Array.isArray(schedules)) {
-    return schedules.map(item => ({
-      start_at: item.start_at || item.start || item.start_time,
-      end_at: item.end_at || item.end || item.end_time
-    })).filter(item => item.start_at && item.end_at);
-  }
-  return [];
+function expandScheduleDateRanges(values) {
+  if (!Array.isArray(values)) return [];
+  const dates = new Set();
+  values.forEach(value => {
+    if (typeof value === 'string') {
+      try {
+        dates.add((0, _localClock.formatLocalDate)((0, _localClock.parseLocalDate)(value.slice(0, 10))));
+      } catch {
+        // Ignore invalid configuration entries.
+      }
+      return;
+    }
+    const startValue = value?.start || value?.start_date || value?.date;
+    const endValue = value?.end || value?.end_date || startValue;
+    let start;
+    let end;
+    try {
+      start = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(String(startValue).slice(0, 10)));
+      end = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(String(endValue).slice(0, 10)));
+    } catch {
+      return;
+    }
+    if (end < start) return;
+    let cursor = start;
+    let guard = 0;
+    while (cursor <= end && guard < MAX_AVAILABILITY_RANGE_DAYS) {
+      dates.add((0, _localClock.formatLocalDate)(cursor));
+      cursor = (0, _localClock.addLocalCalendarDays)(cursor, 1);
+      guard += 1;
+    }
+  });
+  return Array.from(dates).sort();
 }
-
-/**
- * Preserves form ownership while flattening default/optional resource ids.
- * `formId` must survive because the order API requires it under booking.resources[].
- */
-function normalizeRequirements(product) {
+function normalizeRequirementGroups(product) {
   const resources = product.product_resource?.resources;
   if (!Array.isArray(resources)) return [];
-  return resources.filter(resource => resource?.status !== 0).map(resource => ({
-    formId: toNumberId(resource.id),
-    resourceIds: [...(Array.isArray(resource.default_resource) ? resource.default_resource : []), ...(Array.isArray(resource.optional_resource) ? resource.optional_resource : [])].map(id => toNumberId(id)).filter(id => id !== undefined),
-    resourceType: resource.type || resource.select_type?.type || 'single',
-    required: resource.status === 1,
-    capacityRequired: Number(product.capacity?.default || product.capacity || 1) || 1
-  }));
+  return resources.filter(resource => resource?.status !== 0).map((resource, index) => {
+    const formId = toNumberId(resource.id ?? resource.form_id);
+    const required = resource.required ?? resource.status === 1;
+    const resourceType = normalizeResourceType(resource.type);
+    const combinedIds = resource.combined_resource?.status === 1 ? resource.combined_resource?.resource_ids : [];
+    const resourceIds = uniqueAvailabilityIds([...(Array.isArray(resource.default_resource) ? resource.default_resource : []), ...(Array.isArray(resource.optional_resource) ? resource.optional_resource : []), ...(Array.isArray(combinedIds) ? combinedIds : [])]);
+    const min = required ? 1 : 0;
+    const max = 1;
+    return {
+      id: String(formId ?? resource.code ?? `requirement-${index}`),
+      formId,
+      title: pickLocalizedText(resource.title || resource.name || resource.main_field),
+      code: resource.code,
+      resourceType,
+      required: Boolean(required),
+      min,
+      max,
+      resourceIds,
+      capacityRequired: Math.max(1, Number(resource.capacity_required ?? product.capacity?.default ?? product.capacity ?? 1) || 1),
+      raw: resource
+    };
+  });
+}
+function normalizeScheduleRepeatType(value) {
+  if (value === 'daily' || value === 1 || value === '1') return 'daily';
+  if (value === 'weekly' || value === 2 || value === '2') return 'weekly';
+  return 'none';
+}
+function normalizeAbsoluteSessionRange(params) {
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const range = normalizeAvailabilityLocalDateTimeRange({
+    startAt: params.startAt,
+    endAt: params.endAt,
+    fixedOffsetMinutes,
+    rollOverEnd: true
+  });
+  if (!range) return null;
+  return {
+    startAt: range.startAt,
+    endAt: range.endAt,
+    scheduleRefs: [{
+      scheduleId: params.scheduleId,
+      timeSlotId: params.timeSlotId,
+      source: params.source
+    }]
+  };
+}
+function normalizeScheduleItem(schedule, fixedOffsetMinutes) {
+  const rules = [];
+  const ranges = [];
+  const scheduleId = toNumberId(schedule.id ?? schedule.schedule_id);
+  const repeatType = normalizeScheduleRepeatType(schedule.repeat_type);
+  const repeatRule = schedule.repeat_rule || {};
+  const startAt = schedule.start_at || schedule.start || schedule.start_time;
+  const endAt = schedule.end_at || schedule.end || schedule.end_time;
+  const startDate = startAt ? String(startAt).slice(0, 10) : undefined;
+  const configuredEndDate = repeatRule.end?.type === 'date' ? repeatRule.end?.end_date : undefined;
+  const endDate = configuredEndDate ? String(configuredEndDate).slice(0, 10) : undefined;
+  const includedDates = expandScheduleDateRanges(repeatRule.included_date);
+  const excludedDates = expandScheduleDateRanges(repeatRule.excluded_date);
+  const addRule = params => {
+    const mode = repeatType === 'weekly' ? 'weekly' : 'daily';
+    rules.push({
+      id: `${String(scheduleId ?? 'schedule')}:${params.idSuffix}`,
+      mode,
+      startTime: params.startTime.slice(0, 5),
+      endTime: params.endTime.slice(0, 5),
+      startDate,
+      endDate,
+      frequency: Math.max(1, Number(repeatRule.frequency || 1)),
+      weekdays: repeatType === 'weekly' ? (repeatRule.frequency_date || []).map(Number).filter(Number.isFinite) : undefined,
+      includeDates: includedDates,
+      excludeDates: excludedDates,
+      scheduleRef: {
+        scheduleId,
+        timeSlotId: params.timeSlotId,
+        source: `schedule_${schedule.type || 'standard'}`
+      }
+    });
+  };
+  if (schedule.type === 'designation') {
+    const designations = Array.isArray(schedule.designation) ? schedule.designation : schedule.designation ? [schedule.designation] : [];
+    designations.forEach(designation => {
+      const range = normalizeAbsoluteSessionRange({
+        startAt: `${designation.start_date} ${designation.start_time}`,
+        endAt: `${designation.end_date || designation.start_date} ${designation.end_time}`,
+        scheduleId,
+        source: 'schedule_designation',
+        fixedOffsetMinutes
+      });
+      if (range) ranges.push(range);
+    });
+    return {
+      rules,
+      ranges
+    };
+  }
+  if (schedule.type === 'time-slots' && Array.isArray(schedule.time_slot)) {
+    schedule.time_slot.forEach((slot, index) => {
+      if (!slot.start_time || !slot.end_time) return;
+      if (repeatType === 'none' && startDate) {
+        const range = normalizeAbsoluteSessionRange({
+          startAt: `${startDate} ${slot.start_time}`,
+          endAt: `${startDate} ${slot.end_time}`,
+          scheduleId,
+          timeSlotId: toNumberId(slot.id),
+          source: 'schedule_time_slot',
+          fixedOffsetMinutes
+        });
+        if (range) ranges.push(range);
+        return;
+      }
+      addRule({
+        idSuffix: `slot-${String(slot.id ?? index)}`,
+        startTime: slot.start_time,
+        endTime: slot.end_time,
+        timeSlotId: toNumberId(slot.id)
+      });
+    });
+    return {
+      rules,
+      ranges
+    };
+  }
+  if (startAt && endAt) {
+    if (repeatType === 'none') {
+      const range = normalizeAbsoluteSessionRange({
+        startAt,
+        endAt,
+        scheduleId,
+        source: 'schedule_standard',
+        fixedOffsetMinutes
+      });
+      if (range) ranges.push(range);
+    } else {
+      try {
+        addRule({
+          idSuffix: 'standard',
+          startTime: (0, _localClock.formatLocalTime)(String(startAt), false),
+          endTime: (0, _localClock.formatLocalTime)(String(endAt), false)
+        });
+      } catch {
+        // Invalid schedule boundaries do not produce a recurring rule.
+      }
+    }
+  }
+  return {
+    rules,
+    ranges
+  };
+}
+function resolveProductScheduleItems(product, scheduleList) {
+  const scheduleMap = new Map(scheduleList.map(schedule => [String(schedule.id), schedule]));
+  const rawSchedules = [product.schedules, product.schedule, product._schedule].flatMap(value => Array.isArray(value) ? value : value ? [value] : []);
+  const explicitIds = uniqueAvailabilityIds([...(Array.isArray(product['schedule.ids']) ? product['schedule.ids'] : []), ...(Array.isArray(product.schedule_ids) ? product.schedule_ids : []), ...rawSchedules.filter(item => typeof item !== 'object')]);
+  const result = new Map();
+  rawSchedules.filter(item => item && typeof item === 'object').forEach(schedule => {
+    result.set(String(schedule.id ?? JSON.stringify(schedule)), schedule);
+  });
+  explicitIds.forEach(id => {
+    const schedule = scheduleMap.get(String(id));
+    if (schedule) result.set(String(id), schedule);
+  });
+  return Array.from(result.values());
 }
 
-/** Converts a ProductList record into the pure input shape consumed by ResourcePlanner. */
-function normalizeProductForPlanner(product) {
+/** Converts ProductList and schedule records into the pure Availability vocabulary. */
+function normalizeProductForAvailability(product, scheduleList = [], fixedOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)()) {
   const raw = product;
   const kind = resolveProductKind(raw);
+  const isFlexibleDuration = kind === 'duration' && (0, _utils.isProductFlexibleDuration)(raw.duration);
+  const sessionRules = [];
+  const sessionRanges = [];
+  const explicitSession = raw.cartDetailValue?.session || raw._extend?.other?.session || raw.session;
+  const explicitRange = normalizeAbsoluteSessionRange({
+    startAt: explicitSession?.start_at,
+    endAt: explicitSession?.end_at,
+    scheduleId: toNumberId(explicitSession?.schedule_id),
+    timeSlotId: toNumberId(explicitSession?.time_slot_id),
+    source: 'product_session',
+    fixedOffsetMinutes
+  });
+  if (explicitRange) sessionRanges.push(explicitRange);
+  resolveProductScheduleItems(raw, scheduleList).forEach(schedule => {
+    const normalized = normalizeScheduleItem(schedule, fixedOffsetMinutes);
+    sessionRules.push(...normalized.rules);
+    sessionRanges.push(...normalized.ranges);
+  });
   return {
     id: raw.id ?? raw.product_id,
     title: pickLocalizedText(raw.title || raw.name || raw.product_title),
     kind,
-    durationMinutes: Number(raw.duration?.value || raw.duration || raw.service_duration || 30) || 30,
-    schedule: normalizeSchedule(raw),
-    resourceRequirements: normalizeRequirements(raw),
-    capacityRequired: Number(raw.capacity?.default || raw.capacity || 1) || 1,
-    quantity: Number(raw.num || raw.quantity || 1) || 1,
-    price: raw.price ?? raw.selling_price ?? raw.base_price,
+    isFlexibleDuration: isFlexibleDuration || undefined,
+    durationMinutes: kind === 'duration' && !isFlexibleDuration ? Math.max(1, Number(raw.duration?.value || raw.duration || raw.service_duration || 30) || 30) : undefined,
+    requirementGroups: normalizeRequirementGroups(raw),
+    sessionRules,
+    sessionRanges,
+    capacityRequired: Math.max(1, Number(raw.capacity?.default || raw.capacity || 1) || 1),
+    quantity: Math.max(1, Number(raw.num || raw.quantity || 1) || 1),
+    cutOffPolicy: normalizeAvailabilityCutOffPolicy(raw.cut_off_time),
     raw
   };
 }
-function normalizeResourceType(value) {
-  if (value === 'multiple' || value === 'capacity') return value;
-  return 'single';
+function normalizeAvailabilityCutOffNumber(value, context) {
+  if (value == null) {
+    return {
+      reason: `${context} 缺失`
+    };
+  }
+  if (typeof value === 'string' && !value.trim()) {
+    return {
+      reason: `${context} 缺失`
+    };
+  }
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized < 0) {
+    return {
+      reason: `${context} 必须是非负有限数`
+    };
+  }
+  return {
+    value: normalized
+  };
+}
+function normalizeAvailabilityCutOffInteger(value, context) {
+  const numeric = normalizeAvailabilityCutOffNumber(value, context);
+  if (numeric.reason) return numeric;
+  if (!Number.isInteger(numeric.value)) {
+    return {
+      reason: `${context} 必须是非负整数`
+    };
+  }
+  return {
+    value: numeric.value
+  };
+}
+function invalidAvailabilityCutOffPolicy(reason) {
+  return {
+    type: 'invalid',
+    reason
+  };
+}
+function normalizeAvailabilityFutureDay(raw) {
+  if (!Object.prototype.hasOwnProperty.call(raw, 'future_day')) return {};
+  const futureDay = normalizeAvailabilityCutOffInteger(raw.future_day, 'cut_off_time.future_day');
+  return futureDay.reason ? {
+    reason: futureDay.reason
+  } : {
+    futureDay: futureDay.value
+  };
+}
+function normalizeAvailabilityCutOffPolicy(raw) {
+  if (raw == null || raw === '') return undefined;
+  if (!isRecord(raw)) {
+    return invalidAvailabilityCutOffPolicy('cut_off_time 必须是对象');
+  }
+  const futureDay = normalizeAvailabilityFutureDay(raw);
+  if (futureDay.reason) {
+    return invalidAvailabilityCutOffPolicy(futureDay.reason);
+  }
+  const type = String(raw.type ?? '').trim();
+  if (!type) {
+    return invalidAvailabilityCutOffPolicy('cut_off_time.type 缺失');
+  }
+  if (type === 'ongoing') {
+    if (!isRecord(raw.ongoing)) {
+      return invalidAvailabilityCutOffPolicy('cut_off_time.ongoing 缺失');
+    }
+    const ongoingType = String(raw.ongoing.type ?? '').trim();
+    if (ongoingType === 'before_end') {
+      return {
+        type: 'ongoing',
+        mode: 'before_end',
+        ...(futureDay.futureDay === undefined ? {} : {
+          futureDay: futureDay.futureDay
+        })
+      };
+    }
+    if (ongoingType === 'after_start') {
+      const graceMinutes = normalizeAvailabilityCutOffNumber(raw.ongoing.unit, 'cut_off_time.ongoing.unit');
+      return graceMinutes.reason ? invalidAvailabilityCutOffPolicy(graceMinutes.reason) : {
+        type: 'ongoing',
+        mode: 'after_start',
+        graceMinutes: graceMinutes.value,
+        ...(futureDay.futureDay === undefined ? {} : {
+          futureDay: futureDay.futureDay
+        })
+      };
+    }
+    return invalidAvailabilityCutOffPolicy(`未知的 cut_off_time.ongoing.type: ${ongoingType}`);
+  }
+  if (type === 'before_start') {
+    return {
+      type: 'before_start',
+      ...(futureDay.futureDay === undefined ? {} : {
+        futureDay: futureDay.futureDay
+      })
+    };
+  }
+  if (type === 'advance') {
+    const unit = normalizeAvailabilityCutOffNumber(raw.unit, 'cut_off_time.unit');
+    if (unit.reason) return invalidAvailabilityCutOffPolicy(unit.reason);
+    const unitType = String(raw.unit_type ?? '').trim();
+    if (!['days', 'hours', 'minutes'].includes(unitType)) {
+      return invalidAvailabilityCutOffPolicy('cut_off_time.unit_type 必须是 days|hours|minutes');
+    }
+    return {
+      type: 'advance',
+      unit: unit.value,
+      unitType: unitType,
+      ...(futureDay.futureDay === undefined ? {} : {
+        futureDay: futureDay.futureDay
+      })
+    };
+  }
+  return invalidAvailabilityCutOffPolicy(`未知的 cut_off_time.type: ${type}`);
 }
-function normalizeResource(raw) {
+function normalizeResource(raw, fixedOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)()) {
   const id = raw.resourceId ?? raw.resource_id ?? raw.id;
   if (id === undefined || id === null || id === '') return null;
-  const combinedResourceIds = raw.combined_resource?.resource_ids;
+  const rawWindows = raw.windows || raw.times || [];
   return {
     id,
     formId: raw.formId ?? raw.form_id ?? raw.resource_form_id,
     name: raw.resourceName || raw.main_field || raw.name || raw.title,
-    resourceType: normalizeResourceType(raw.type || raw.resourceType || raw.select_type?.type),
-    capacity: Number(raw.capacity || raw.max_capacity || 1) || 1,
-    times: Array.isArray(raw.times) ? raw.times : [],
-    childResourceIds: Array.isArray(combinedResourceIds) ? combinedResourceIds : undefined,
+    code: raw.code,
+    resourceType: normalizeResourceType(raw.type || raw.resourceType),
+    capacity: Math.max(1, Number(raw.capacity || raw.max_capacity || 1) || 1),
+    windows: (Array.isArray(rawWindows) ? rawWindows : []).flatMap(window => {
+      const range = normalizeAvailabilityLocalDateTimeRange({
+        startAt: window.startAt || window.start_at || window.start,
+        endAt: window.endAt || window.end_at || window.end,
+        fixedOffsetMinutes,
+        rollOverEnd: true
+      });
+      if (!range) return [];
+      return [{
+        startAt: range.startAt,
+        endAt: range.endAt,
+        source: window.source,
+        raw: window
+      }];
+    }),
     raw
   };
 }
@@ -232,79 +684,62 @@ function normalizeScheduleIds(raw) {
   const ids = raw.schedule ?? raw.schedule_ids ?? raw.scheduleIds ?? [];
   return (Array.isArray(ids) ? ids : [ids]).map(id => toNumberId(id)).filter(id => id !== undefined);
 }
-function collectRawScheduleIds(rawResources) {
-  const ids = new Map();
-  (rawResources || []).forEach(resource => {
-    normalizeScheduleIds(resource).forEach(id => {
-      ids.set(String(id), id);
-    });
-  });
-  return Array.from(ids.values());
-}
-function scheduleListHasIds(scheduleList, scheduleIds) {
-  if (!scheduleIds.length) return true;
-  const existingIds = new Set((scheduleList || []).map(schedule => String(schedule.id)));
-  return scheduleIds.every(id => existingIds.has(String(id)));
-}
 function dateRangeDays(dateRange) {
-  if (!dateRange?.start || !dateRange?.end) return [];
+  if (!dateRange?.startDate || !dateRange?.endDate) return [];
   const dates = [];
-  let cursor = (0, _dayjs.default)(dateRange.start);
-  const end = (0, _dayjs.default)(dateRange.end);
-  if (!cursor.isValid() || !end.isValid() || end.isBefore(cursor, 'day')) return dates;
-  while (cursor.isSame(end, 'day') || cursor.isBefore(end, 'day')) {
-    dates.push(cursor.format('YYYY-MM-DD'));
-    cursor = cursor.add(1, 'day');
+  const startScalar = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(dateRange.startDate));
+  const endScalar = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(dateRange.endDate));
+  if (endScalar < startScalar) return dates;
+  for (let cursor = startScalar; cursor <= endScalar; cursor = (0, _localClock.addLocalCalendarDays)(cursor, 1)) {
+    dates.push((0, _localClock.formatLocalDate)(cursor));
   }
   return dates;
 }
-function normalizePlannerEvent(rawEvent, resourceId) {
-  const startAt = rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime;
-  const endAt = rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime;
-  if (!startAt || !endAt) return null;
-  const rawSource = rawEvent.source;
-  const source = rawSource === 'remote' || rawSource === 'cart' || rawSource === 'selection' ? rawSource : 'remote';
+function normalizeResourceOccupancy(rawEvent, resourceId, source = 'remote', fixedOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)()) {
+  const range = normalizeAvailabilityLocalDateTimeRange({
+    startAt: rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime,
+    endAt: rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime,
+    fixedOffsetMinutes,
+    rollOverEnd: false
+  });
+  if (!range) return null;
   return {
-    ...rawEvent,
+    id: rawEvent.id == null ? undefined : String(rawEvent.id),
     resourceId,
-    resource_id: rawEvent.resource_id ?? rawEvent.resourceId ?? resourceId,
-    start_at: startAt,
-    end_at: endAt,
+    startAt: range.startAt,
+    endAt: range.endAt,
     pax: Number(rawEvent.pax ?? rawEvent.number ?? rawEvent.capacity ?? 1) || 1,
-    source
+    source: rawEvent.source === 'cart' || rawEvent.source === 'selection' ? rawEvent.source : source,
+    scheduleEventId: toNumberId(rawEvent.schedule_event_id ?? rawEvent.scheduleEventId),
+    serverEventId: toNumberId(rawEvent.schedule_event_id ?? rawEvent.server_event_id ?? rawEvent.id),
+    bookingUid: rawEvent.booking_uid ?? rawEvent.bookingUid ?? rawEvent.metadata?.unique_identification_number,
+    productUid: rawEvent.product_uid ?? rawEvent.productUid ?? rawEvent.metadata?.product_uid,
+    raw: rawEvent
   };
 }
-function normalizeResourceV2(raw) {
-  const normalized = normalizeResource({
-    ...raw,
-    times: []
-  });
-  if (!normalized) return null;
-  return normalized;
-}
 function buildResourceWindowFallbackTimes(params) {
   const {
     raw,
     dates,
     scheduleIds
   } = params;
-  const rawStart = raw.start_time || raw.start_at || raw.startTime;
-  const rawEnd = raw.end_time || raw.end_at || raw.endTime;
-  if (!rawStart || !rawEnd) return [];
-  const startBoundary = (0, _dayjs.default)(rawStart);
-  const endBoundary = (0, _dayjs.default)(rawEnd);
-  if (!startBoundary.isValid() || !endBoundary.isValid() || !endBoundary.isAfter(startBoundary)) {
-    return [];
-  }
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const boundary = normalizeAvailabilityLocalDateTimeRange({
+    startAt: raw.start_time || raw.start_at || raw.startTime,
+    endAt: raw.end_time || raw.end_at || raw.endTime,
+    fixedOffsetMinutes,
+    rollOverEnd: true
+  });
+  if (!boundary) return [];
   return dates.flatMap(date => {
-    const dayStart = (0, _dayjs.default)(`${date} 00:00:00`);
-    const dayEnd = (0, _dayjs.default)(`${date} 23:59:59`);
-    const start = startBoundary.isAfter(dayStart) ? startBoundary : dayStart;
-    const end = endBoundary.isBefore(dayEnd) ? endBoundary : dayEnd;
-    if (!end.isAfter(start)) return [];
+    const dayStart = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(`${date}T00:00:00`));
+    const dayEnd = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(`${date}T23:59:59`));
+    const start = Math.max(boundary.startScalar, dayStart);
+    const end = Math.min(boundary.endScalar, dayEnd);
+    if (end <= start) return [];
     return [{
-      start_at: start.format('YYYY-MM-DD HH:mm:ss'),
-      end_at: end.format('YYYY-MM-DD HH:mm:ss'),
+      start_at: (0, _localClock.formatLocalDateTime)(start, fixedOffsetMinutes),
+      end_at: (0, _localClock.formatLocalDateTime)(end, fixedOffsetMinutes),
       schedule_ids: scheduleIds,
       source: 'resource_window_fallback'
     }];
@@ -313,16 +748,18 @@ function buildResourceWindowFallbackTimes(params) {
 
 /**
  * Materializes resource work windows locally from v2's schedule ids, then keeps its flat
- * event_list as planner events. This deliberately avoids the older API's times -> event_list
+ * event_list as resource occupancy records. This deliberately avoids the older API's times -> event_list
  * response nesting and lets one resource response serve any requested date range.
  */
-function buildPlannerResourcesFromV2(params) {
+function buildAvailabilityResourcesFromV2(params) {
   const scheduleMap = new Map((params.scheduleList || []).map(schedule => [String(schedule.id), schedule]));
   const dates = dateRangeDays(params.dateRange);
-  const externalEvents = [];
+  const resourceOccupancies = [];
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, _localClock.captureRuntimeOffsetMinutes)();
   const resources = (params.rawResources || []).map(raw => {
-    const resource = normalizeResourceV2(raw);
+    const resource = normalizeResource(raw, fixedOffsetMinutes);
     if (!resource) return null;
+    const explicitWindows = [...resource.windows];
     const scheduleIds = normalizeScheduleIds(raw);
     const schedules = scheduleIds.map(id => scheduleMap.get(String(id))).filter(Boolean);
     const matchedScheduleIds = new Set(schedules.map(schedule => String(schedule.id)));
@@ -330,36 +767,55 @@ function buildPlannerResourcesFromV2(params) {
     if (missingScheduleIds.length > 0) {
       resource.raw = {
         ...(resource.raw || raw),
-        _plannerMissingScheduleIds: missingScheduleIds
+        _availabilityMissingScheduleIds: missingScheduleIds
       };
     }
-    resource.times = dates.flatMap(date => (0, _getDateIsInSchedule.getScheduleStartEndTimePoints)(date, schedules).map(slot => ({
-      start_at: (0, _dayjs.default)(slot.start_at).format('YYYY-MM-DD HH:mm:ss'),
-      end_at: (0, _dayjs.default)(slot.end_at).format('YYYY-MM-DD HH:mm:ss'),
-      schedule_ids: scheduleIds
+    const materializedWindows = dates.flatMap(date => schedules.flatMap(schedule => (0, _getDateIsInSchedule.getScheduleStartEndTimePoints)(date, [schedule]).flatMap(slot => {
+      const range = normalizeAvailabilityLocalDateTimeRange({
+        startAt: slot.start_at,
+        endAt: slot.end_at,
+        fixedOffsetMinutes,
+        rollOverEnd: true
+      });
+      if (!range) return [];
+      return [{
+        startAt: range.startAt,
+        endAt: range.endAt,
+        source: `resource_schedule:${schedule.id}`,
+        raw: {
+          scheduleId: schedule.id
+        }
+      }];
     })));
-    if (resource.times.length === 0 && missingScheduleIds.length > 0) {
-      resource.times = buildResourceWindowFallbackTimes({
+    resource.windows = materializedWindows.length > 0 ? materializedWindows : explicitWindows;
+    if (resource.windows.length === 0 && missingScheduleIds.length > 0) {
+      resource.windows = buildResourceWindowFallbackTimes({
         raw,
         dates,
-        scheduleIds
-      });
+        scheduleIds,
+        fixedOffsetMinutes
+      }).map(window => ({
+        startAt: window.start_at,
+        endAt: window.end_at,
+        source: window.source,
+        raw: window
+      }));
     }
     const eventList = Array.isArray(raw.event_list) ? raw.event_list : [];
     eventList.forEach(event => {
-      const normalizedEvent = normalizePlannerEvent(event, resource.id);
-      if (normalizedEvent) externalEvents.push(normalizedEvent);
+      const occupancy = normalizeResourceOccupancy(event, resource.id, 'remote', fixedOffsetMinutes);
+      if (occupancy) resourceOccupancies.push(occupancy);
     });
     return resource;
   }).filter(resource => resource !== null);
   return {
     resources,
-    externalEvents
+    resourceOccupancies
   };
 }
 
 /** Combines URL-locked resources with every resource referenced by the selected products. */
-function collectPlannerResourceIds(products, explicitResourceIds = []) {
+function collectAvailabilityResourceIds(products, explicitResourceIds = []) {
   const ids = new Map();
   const add = value => {
     if (value === undefined || value === null || value === '') return;
@@ -367,80 +823,340 @@ function collectPlannerResourceIds(products, explicitResourceIds = []) {
   };
   explicitResourceIds.forEach(add);
   products.forEach(product => {
-    product.resourceRequirements?.forEach(requirement => {
+    product.requirementGroups?.forEach(requirement => {
       requirement.resourceIds?.forEach(add);
     });
   });
   return Array.from(ids.values());
 }
-function samePlannerId(left, right) {
-  if (left === undefined || right === undefined) return false;
-  return String(left) === String(right);
+function getProductLineUid(product) {
+  return String(product?.metadata?.unique_identification_number ?? product?.unique_identification_number ?? '');
 }
-function findRequirementForAssignment(product, assignment) {
-  const requirements = product.resourceRequirements || [];
-  return requirements.find(requirement => (requirement.resourceIds || []).some(id => samePlannerId(id, assignment.resourceId))) || (requirements.length === 1 ? requirements[0] : undefined) || requirements.find(requirement => requirement.required) || requirements[0];
+function buildAvailabilityLineIdentity(product) {
+  return {
+    product_id: product.product_id,
+    product_variant_id: product.product_variant_id ?? 0,
+    unique_identification_number: getProductLineUid(product),
+    product_sku: product.product_sku,
+    product_bundle: product.product_bundle
+  };
 }
-
-/** Convenience wrapper for the usual one-resource booking case. */
-function buildBookingFromAssignment(params) {
-  return buildBookingFromAssignments({
+function buildBookingFromAvailabilityAssignment(params) {
+  return buildBookingFromAvailabilityAssignments({
+    product: params.product,
     assignments: [params.assignment],
+    timezone: params.timezone,
+    fixedOffsetMinutes: params.fixedOffsetMinutes
+  });
+}
+function buildBookingFromAvailabilityAssignments(params) {
+  const normalizedAssignments = (params.assignments || []).map(assignment => {
+    const resourceId = assignment.resourceId ?? assignment.resource_id;
+    const matchedGroup = (params.product.requirementGroups || []).find(group => group.resourceIds?.some(id => sameAvailabilityId(id, resourceId)));
+    return {
+      productId: assignment.productId ?? assignment.product_id,
+      resourceId,
+      formId: assignment.formId ?? assignment.form_id ?? matchedGroup?.formId,
+      startAt: assignment.startAt ?? assignment.start_at,
+      endAt: assignment.endAt ?? assignment.end_at,
+      capacityRequired: assignment.capacityRequired ?? assignment.capacity_required ?? matchedGroup?.capacityRequired,
+      scheduleId: assignment.scheduleId ?? assignment.schedule_id,
+      timeSlotId: assignment.timeSlotId ?? assignment.time_slot_id
+    };
+  });
+  const first = normalizedAssignments[0];
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const range = normalizeAvailabilityLocalDateTimeRange({
+    startAt: first.startAt,
+    endAt: first.endAt,
+    fixedOffsetMinutes,
+    rollOverEnd: false
+  });
+  if (!range) {
+    throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'assignment 时间范围非法', {
+      assignments: params.assignments
+    });
+  }
+  const candidate = {
+    key: `${String(first.productId)}:${range.startAt}:${range.endAt}`,
+    productId: first.productId,
+    source: 'duration_window',
+    startAt: range.startAt,
+    endAt: range.endAt,
+    bookingStartAt: range.startAt,
+    bookingEndAt: range.endAt,
+    date: range.startAt.slice(0, 10),
+    startTime: (0, _localClock.formatLocalTime)(range.startAt, false),
+    endTime: (0, _localClock.formatLocalTime)(range.endAt, false),
+    timezone: String(params.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || 'runtime'),
+    scheduleRefs: [],
+    primaryScheduleRef: undefined
+  };
+  return buildBookingFromAvailabilitySelection({
+    assignments: normalizedAssignments,
+    candidate,
     product: params.product
   });
 }
-
-/**
- * Converts all resources needed by one product/time interval into the one booking expected by
- * OrderModule. Callers must group assignments before this function so a multi-form booking does
- * not become several competing bookings.
- */
-function buildBookingFromAssignments(params) {
+function getBookingUid(booking) {
+  return String(booking?.metadata?.unique_identification_number ?? booking?.booking_uid ?? '');
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.keys(value).sort().reduce((result, key) => {
+    if (value[key] !== undefined && typeof value[key] !== 'function') {
+      result[key] = stableValue(value[key]);
+    }
+    return result;
+  }, {});
+}
+function hashText(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function resolveOrderRevision(tempOrder) {
+  if (!tempOrder) return 'order:none';
+  const products = (Array.isArray(tempOrder.products) ? tempOrder.products : []).map(product => ({
+    uid: getProductLineUid(product),
+    productId: product.product_id ?? product.id,
+    variantId: product.product_variant_id ?? 0,
+    num: product.num ?? product.quantity ?? 1,
+    bookingUid: product.booking_uid ?? product.metadata?.booking_uid,
+    productSku: product.product_sku,
+    productBundle: product.product_bundle
+  })).sort((left, right) => left.uid.localeCompare(right.uid));
+  const bookings = (Array.isArray(tempOrder.bookings) ? tempOrder.bookings : []).map(booking => ({
+    uid: getBookingUid(booking),
+    scheduleEventId: booking.schedule_event_id,
+    productUid: booking.product_uid,
+    scheduleId: booking.schedule_id,
+    startDate: booking.start_date,
+    startTime: booking.start_time,
+    endDate: booking.end_date,
+    endTime: booking.end_time,
+    resources: booking.resources
+  })).sort((left, right) => left.uid.localeCompare(right.uid));
+  return `order:${hashText(JSON.stringify(stableValue({
+    products,
+    bookings
+  })))}`;
+}
+function buildBookingFromAvailabilitySelection(params) {
   const {
     assignments,
-    product
+    candidate,
+    product,
+    resources = [],
+    bookingUid,
+    holder,
+    holderIds
   } = params;
-  const firstAssignment = assignments[0];
-  const start = (0, _dayjs.default)(firstAssignment.start_at);
-  const end = (0, _dayjs.default)(firstAssignment.end_at);
+  const bookingStartAt = candidate.bookingStartAt || candidate.startAt;
+  const bookingEndAt = candidate.bookingEndAt || candidate.endAt;
+  const startScalar = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(bookingStartAt));
+  const endScalar = (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(bookingEndAt));
+  const scheduleId = candidate.primaryScheduleRef?.scheduleId ?? assignments.find(assignment => assignment.scheduleId != null)?.scheduleId;
+  const timeSlotId = candidate.primaryScheduleRef?.timeSlotId ?? assignments.find(assignment => assignment.timeSlotId != null)?.timeSlotId;
+  if (product.kind === 'session' && scheduleId == null) {
+    throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', 'session 候选缺少真实 schedule identity', {
+      productId: product.id,
+      candidateKey: candidate.key,
+      scheduleRefs: candidate.scheduleRefs
+    });
+  }
+  const normalizedHolder = holder && typeof holder === 'object' ? (0, _lodashEs.cloneDeep)(holder) : undefined;
+  const normalizedHolderIds = Array.isArray(holderIds) ? (0, _lodashEs.cloneDeep)(holderIds) : holderIds;
   return {
-    start_date: start.format('YYYY-MM-DD'),
-    start_time: start.format('HH:mm'),
-    end_date: end.format('YYYY-MM-DD'),
-    end_time: end.format('HH:mm'),
-    duration: Math.max(1, end.diff(start, 'minute')),
+    start_date: bookingStartAt.slice(0, 10),
+    start_time: bookingStartAt.slice(11, 16),
+    end_date: bookingEndAt.slice(0, 10),
+    end_time: bookingEndAt.slice(11, 16),
+    duration: Math.max(1, Math.trunc((endScalar - startScalar) / (60 * 1000))),
     like_status: 'common',
-    schedule_id: 0,
+    schedule_id: scheduleId ?? 0,
+    ...(normalizedHolder ? {
+      holder: normalizedHolder
+    } : {}),
     resources: assignments.map(assignment => {
-      const requirement = findRequirementForAssignment(product, assignment);
+      // requirementSelections 的提交协议只携带资源 ID；购物车展示则需要名称。
+      // commit 此时仍持有本次不可变 projection，因此直接按 ID 取回名称并
+      // 固化到 booking，避免 UI 再依赖 legacy BookingContext resourcesOriginMap。
+      const matchedResource = resources.find(resource => sameAvailabilityId(resource.id, assignment.resourceId));
+      const resourceName = String(matchedResource?.name || '').trim();
       return {
         id: assignment.resourceId,
         resource_id: assignment.resourceId,
-        form_id: requirement?.formId,
+        form_id: assignment.formId,
         relation_type: 'form',
         relation_id: assignment.resourceId,
         like_status: 'common',
-        capacity: assignment.capacityRequired || product.capacityRequired || 1
+        capacity: assignment.capacityRequired || 1,
+        ...(resourceName ? {
+          metadata: {
+            resource_name: resourceName
+          }
+        } : {})
       };
     }),
     metadata: {
+      ...(bookingUid ? {
+        unique_identification_number: bookingUid
+      } : {}),
       unified_booking_sales: true,
-      planner_source: product.kind
+      availability_candidate_key: candidate.key,
+      availability_source: candidate.source,
+      availability_slice_start_at: candidate.startAt,
+      availability_slice_end_at: candidate.endAt,
+      availability_schedule_refs: candidate.scheduleRefs,
+      ...(timeSlotId == null ? {} : {
+        time_slot_id: timeSlotId
+      }),
+      product_kind: product.kind,
+      ...(normalizedHolderIds === undefined ? {} : {
+        holder_id: normalizedHolderIds
+      }),
+      ...(normalizedHolder ? {
+        holder: (0, _lodashEs.cloneDeep)(normalizedHolder)
+      } : {})
     }
   };
 }
-function buildAssignmentGroupKey(assignment) {
-  return [assignment.productId, assignment.start_at, assignment.end_at].join(':');
+const POS_OVERRIDABLE_AVAILABILITY_CONFLICT_CODES = new Set(['past', 'booking_cutoff', 'resource_full', 'resource_unavailable', 'resource_capacity_exceeded',
+// A required group whose selected resource is outside its window is surfaced
+// as missing_resource at group level. Structural validation below still
+// rejects a genuinely missing selection.
+'missing_resource']);
+const POS_NO_RESOURCE_ID = 0;
+function matchesForcedSelectionGroup(selection, group) {
+  const hasGroupId = typeof selection.requirementGroupId === 'string' && selection.requirementGroupId.trim().length > 0;
+  const hasFormId = selection.formId !== undefined && selection.formId !== null;
+  if (!hasGroupId && !hasFormId) return false;
+  if (hasGroupId && selection.requirementGroupId !== group.id) return false;
+  if (hasFormId && !sameAvailabilityId(selection.formId, group.formId)) return false;
+  return true;
 }
 
-/** Builds the exact identity BaseSales needs to remove only this solution's order lines. */
-function buildPlannerLineIdentity(product) {
+/**
+ * POS may intentionally overbook a configured time/resource. Rebuild the
+ * assignments from the submitted, structurally valid resource identities so
+ * a full/unavailable option is not silently dropped by normal availability
+ * evaluation. This deliberately ignores capacity, occupancy and resource
+ * windows, while retaining product/group/resource identity and selection
+ * cardinality checks.
+ */
+function buildPosForcedAvailabilityAssignments(params) {
+  const {
+    product,
+    resources,
+    candidate,
+    requirementSelections,
+    partySize
+  } = params;
+  const groups = product.requirementGroups || [];
+  const conflicts = [];
+  const assignments = [];
+  const selectionsByGroup = new Map();
+  const addConflict = (code, message, details = {}) => conflicts.push({
+    code,
+    message,
+    productId: candidate.productId,
+    candidateKey: candidate.key,
+    ...details
+  });
+  requirementSelections.forEach(selection => {
+    const matchedGroups = groups.filter(group => matchesForcedSelectionGroup(selection, group));
+    if (matchedGroups.length !== 1) {
+      addConflict('invalid_requirement_group', '选择的资源组不属于当前商品', {
+        requirementGroupId: selection.requirementGroupId,
+        formId: selection.formId
+      });
+      return;
+    }
+    const group = matchedGroups[0];
+    if (selectionsByGroup.has(group.id)) {
+      addConflict('invalid_selection_count', `资源组 ${group.id} 被重复提交`, {
+        requirementGroupId: group.id,
+        formId: group.formId
+      });
+      return;
+    }
+    selectionsByGroup.set(group.id, selection);
+    if (!Array.isArray(selection.resourceIds)) {
+      addConflict('invalid_selection_count', `资源组 ${group.id} 的资源选择必须是数组`, {
+        requirementGroupId: group.id,
+        formId: group.formId
+      });
+      return;
+    }
+    const selectedResourceIds = Array.from(new Map(selection.resourceIds.map(resourceId => [String(resourceId), resourceId])).values());
+    const required = group.required !== false;
+    const min = Math.max(required ? 1 : 0, Number(group.min ?? (required ? 1 : 0)) || 0);
+    const max = Math.max(min, Number(group.max ?? Math.max(min, 1)) || Math.max(min, 1));
+    if (selectedResourceIds.length < min) {
+      addConflict('missing_resource', `资源组 ${group.id} 缺少已选资源`, {
+        requirementGroupId: group.id,
+        formId: group.formId
+      });
+      return;
+    }
+    if (selectedResourceIds.length > max) {
+      addConflict('invalid_selection_count', `资源组 ${group.id} 已选资源数量超出上限`, {
+        requirementGroupId: group.id,
+        formId: group.formId
+      });
+      return;
+    }
+    selectedResourceIds.forEach(resourceId => {
+      if (sameAvailabilityId(resourceId, POS_NO_RESOURCE_ID)) {
+        assignments.push({
+          productId: product.id,
+          resourceId: POS_NO_RESOURCE_ID,
+          formId: group.formId ?? selection.formId,
+          startAt: candidate.bookingStartAt || candidate.startAt,
+          endAt: candidate.bookingEndAt || candidate.endAt,
+          capacityRequired: Math.max(1, partySize),
+          scheduleId: candidate.primaryScheduleRef?.scheduleId,
+          timeSlotId: candidate.primaryScheduleRef?.timeSlotId
+        });
+        return;
+      }
+      const resource = resources.find(item => sameAvailabilityId(item.id, resourceId));
+      const belongsToGroup = Boolean(resource && !(group.formId !== undefined && resource.formId !== undefined && !sameAvailabilityId(group.formId, resource.formId)) && !(group.resourceIds?.length && !group.resourceIds.some(id => sameAvailabilityId(id, resourceId))));
+      if (!resource || !belongsToGroup) {
+        addConflict('resource_unavailable', `资源 ${String(resourceId)} 不属于当前商品资源组`, {
+          requirementGroupId: group.id,
+          formId: group.formId,
+          resourceId
+        });
+        return;
+      }
+      assignments.push({
+        productId: product.id,
+        resourceId,
+        formId: group.formId ?? resource.formId,
+        startAt: candidate.bookingStartAt || candidate.startAt,
+        endAt: candidate.bookingEndAt || candidate.endAt,
+        capacityRequired: Math.max(1, partySize),
+        scheduleId: candidate.primaryScheduleRef?.scheduleId,
+        timeSlotId: candidate.primaryScheduleRef?.timeSlotId
+      });
+    });
+  });
+  groups.filter(group => group.required !== false).forEach(group => {
+    if (selectionsByGroup.has(group.id)) return;
+    addConflict('missing_resource', `资源组 ${group.id} 缺少已选资源`, {
+      requirementGroupId: group.id,
+      formId: group.formId
+    });
+  });
   return {
-    product_id: product.product_id,
-    product_variant_id: product.product_variant_id ?? 0,
-    unique_identification_number: product.metadata?.unique_identification_number || product.unique_identification_number,
-    product_sku: product.product_sku,
-    product_bundle: product.product_bundle
+    assignments,
+    conflicts
   };
 }
 class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
@@ -451,55 +1167,375 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
   openDataTarget = null;
   loadOpenDataInFlight = null;
   loadOpenDataInFlightTarget = null;
+  availabilityRuntimeOffsetMinutes = null;
+  availabilityScheduleCatalog = null;
+  availabilityProjectionSequence = 0;
+  availabilityContextSequence = 0;
+  availabilityLifecycleGeneration = 0;
+  availabilityContextRegistry = new Map();
+  availabilityProjectionPool = new Map();
+  availabilityPrepareInFlight = new Map();
+  availabilityProjectionRefreshInFlight = new Map();
+  availabilityRemoteOccupancyCache = new _remoteOccupancyCache.AvailabilityRemoteOccupancyCache(MAX_REMOTE_OCCUPANCY_RESOURCE_DATE_CELLS);
+  availabilityRemoteResourceQueryInFlight = new Map();
+  availabilityRemoteResourceQuerySequence = 0;
+  availabilityRemoteResourceEpoch = 0;
+  availabilityCommitLocks = new Set();
+  allergyItemRuleEvaluator = new _itemRule.ItemRuleEvaluator();
+  allergyItemRuleConfigs = [];
+  allergyItemRuleConfigsPromise = null;
+  async initialize(core, options = {}) {
+    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}`;
+    }
+    this.captureAvailabilityScheduleCatalog();
+  }
   getSubmitOrderSalesChannel() {
     const channel = String(this.otherParams?.channel ?? '').trim();
     return channel || super.getSubmitOrderSalesChannel();
   }
-  isSessionStoragePersistEnabled() {
-    return Boolean(this.cacheId && this.otherParams?.enableSessionStoragePersist === true);
+  createAvailabilityFacadeError(code, message, details) {
+    return new _ResourcePlanner.AvailabilityError(code, message, details);
   }
-  shouldUseSessionStorageForSubModule(moduleName) {
-    return this.isSessionStoragePersistEnabled() && moduleName === 'order';
+  getAvailabilityScopeDescriptor(otherParams = this.otherParams || {}) {
+    return {
+      cacheId: this.cacheId || '',
+      businessCode: String(otherParams.businessCode ?? otherParams.business_code ?? ''),
+      channel: String(otherParams.channel ?? ''),
+      platform: String(otherParams.platform ?? ''),
+      businessTimezone: String(otherParams.businessTimezone ?? '')
+    };
   }
-
-  /**
-   * 读取与当前 cacheId 同分桶的 Solution 会话状态。
-   * 该状态独立于 otherParams，适合页面皮肤保存短生命周期 UI 状态。
-   */
-  getSessionStateValue(key) {
-    if (!key || !this.isSessionStoragePersistEnabled()) return undefined;
-    const cacheData = this.readSessionCacheData();
-    const solutionCache = cacheData?.[this.name];
-    if (!isRecord(solutionCache) || !isRecord(solutionCache.sessionState)) {
-      return undefined;
-    }
-    return solutionCache.sessionState[key];
+  normalizeAvailabilityIdList(values) {
+    if (!Array.isArray(values) || values.length === 0) return undefined;
+    const uniqueMap = new Map();
+    values.forEach(value => {
+      uniqueMap.set(String(value), value);
+    });
+    return Array.from(uniqueMap.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([, value]) => value);
   }
-
-  /**
-   * 写入与当前 cacheId 同分桶的 Solution 会话状态。
-   * value 为 undefined 时删除该 key；存储失败不阻断业务流程。
-   */
-  setSessionStateValue(key, value) {
-    if (!key || !this.isSessionStoragePersistEnabled()) return;
-    const cacheData = this.readSessionCacheData();
-    const solutionCache = cacheData?.[this.name];
-    const currentSessionState = isRecord(solutionCache) && isRecord(solutionCache.sessionState) ? solutionCache.sessionState : {};
-    const nextSessionState = {
-      ...currentSessionState
-    };
-    if (value === undefined) {
-      delete nextSessionState[key];
-    } else {
-      nextSessionState[key] = value;
+  normalizeAvailabilityStringList(values) {
+    if (!Array.isArray(values) || values.length === 0) return undefined;
+    return Array.from(new Set(values.map(String))).sort((left, right) => left.localeCompare(right));
+  }
+  normalizeAvailabilityPrepareDescriptor(params) {
+    this.assertAvailabilityPrepareParams(params);
+    const timezone = String(params.timezone || this.otherParams?.businessTimezone || Intl.DateTimeFormat().resolvedOptions().timeZone || 'Asia/Shanghai');
+    assertValidAvailabilityTimezone(timezone);
+    const dateRange = this.normalizeAvailabilityDateRange(params, timezone);
+    const slotStepMinutes = params.slotStepMinutes || DEFAULT_AVAILABILITY_SLOT_STEP_MINUTES;
+    const businessHours = params.businessHours || DEFAULT_AVAILABILITY_BUSINESS_HOURS;
+    const mode = params.mode || 'appointment';
+    if (!isValidClockTime(businessHours.startTime) || !isValidClockTime(businessHours.endTime)) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'businessHours 必须使用 HH:mm', {
+        businessHours
+      });
     }
-    this.checkSaveCache({
-      cacheId: this.cacheId,
-      fatherModule: this.name,
-      store: {
-        sessionState: nextSessionState
+    return this.cloneAvailabilityPrepareParams({
+      ...params,
+      productIds: this.normalizeAvailabilityIdList(params.productIds),
+      resourceIds: this.normalizeAvailabilityIdList(params.resourceIds),
+      editingProductLineUids: this.normalizeAvailabilityStringList(params.editingProductLineUids),
+      dateRange,
+      timezone,
+      slotStepMinutes,
+      businessHours: {
+        ...businessHours
       },
-      cacheKey: ['sessionState']
+      _availabilityOperatingHours: params._availabilityOperatingHours ? {
+        source: params._availabilityOperatingHours.source,
+        scheduleIds: [...params._availabilityOperatingHours.scheduleIds]
+      } : undefined,
+      mode
+    });
+  }
+  async resolveAvailabilityPrepareDefaults(params) {
+    const needsOperatingHours = params.businessHours === undefined;
+    const needsTimeSlice = params.slotStepMinutes === undefined;
+    if (!needsOperatingHours && !needsTimeSlice) {
+      return {
+        ...params,
+        _availabilityOperatingHours: {
+          source: 'prepare_business_hours',
+          scheduleIds: []
+        }
+      };
+    }
+    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;
+    if (!openData && this.store.openData) {
+      try {
+        openData = await this.getOpenData();
+      } catch (error) {
+        if (needsOperatingHours) {
+          throw this.createAvailabilityFacadeError('OPERATING_HOURS_RESOLVE_FAILED', '无法读取店铺营业时间配置，请重试', {
+            businessCode,
+            channel,
+            cause: error instanceof Error ? error.message : String(error)
+          });
+        }
+        console.warn('[UnifiedBookingSales] OpenData 时间切片配置加载失败，回退为默认值', error);
+      }
+    }
+    const operatingScheduleIds = this.normalizeAvailabilityIdList(Array.isArray(openData?.['availability.operating_hours']) ? openData?.['availability.operating_hours'] : undefined) || [];
+    const configuredTimeSlice = needsTimeSlice ? normalizePositiveInteger(openData?.['reservation.time_slice']) : undefined;
+    return {
+      ...params,
+      ...(configuredTimeSlice ? {
+        slotStepMinutes: configuredTimeSlice
+      } : {}),
+      _availabilityOperatingHours: needsOperatingHours ? {
+        source: operatingScheduleIds.length > 0 ? 'open_data_schedule' : 'default_business_hours',
+        scheduleIds: operatingScheduleIds
+      } : {
+        source: 'prepare_business_hours',
+        scheduleIds: []
+      }
+    };
+  }
+  buildAvailabilityPrepareKey(params) {
+    const normalizedParams = this.normalizeAvailabilityPrepareDescriptor(params);
+    return JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      prepare: normalizedParams
+    }));
+  }
+  clearAvailabilityRemoteResourceState() {
+    this.availabilityRemoteResourceEpoch += 1;
+    this.availabilityRemoteOccupancyCache.clear();
+    this.availabilityRemoteResourceQueryInFlight.clear();
+    this.availabilityRemoteResourceQuerySequence = 0;
+  }
+  buildAvailabilityRemoteResourceScopeKey(timezoneName) {
+    return JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      timezone: timezoneName
+    }));
+  }
+  buildAvailabilityRemoteResourceQueryKey(params) {
+    return JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      timezone: params.timezone,
+      dateRange: params.dateRange,
+      resourceIds: this.normalizeAvailabilityIdList(params.resourceIds) || []
+    }));
+  }
+  async setOtherParams(params, {
+    cover = false
+  } = {}) {
+    const previousScope = this.getAvailabilityScopeDescriptor(this.otherParams || {});
+    const previousItemRuleConfig = this.otherParams?.itemRule;
+    const explicitlySetsOpenData = Object.prototype.hasOwnProperty.call(params, 'openData');
+    await super.setOtherParams(params, {
+      cover
+    });
+    const nextScope = this.getAvailabilityScopeDescriptor(this.otherParams || {});
+    if (explicitlySetsOpenData) {
+      this.openDataTarget = this.otherParams?.openData && nextScope.businessCode && nextScope.channel ? `${nextScope.businessCode}+${nextScope.channel}` : null;
+    }
+    const shouldResetAvailabilityState = previousScope.cacheId !== nextScope.cacheId || previousScope.businessCode !== nextScope.businessCode || previousScope.channel !== nextScope.channel || previousScope.platform !== nextScope.platform || previousScope.businessTimezone !== nextScope.businessTimezone;
+    if (shouldResetAvailabilityState) {
+      await this.resetAvailabilityProjectionState('set_other_params_reset');
+    }
+    if (shouldResetAvailabilityState || explicitlySetsOpenData || previousItemRuleConfig !== this.otherParams?.itemRule) {
+      this.resetAllergyItemRuleState();
+    }
+  }
+  async destroy() {
+    this.availabilityScheduleCatalog = null;
+    this.availabilityRuntimeOffsetMinutes = null;
+    await this.resetAvailabilityProjectionState('destroy');
+    this.resetAllergyItemRuleState();
+    await super.destroy();
+  }
+  createAvailabilityContextId() {
+    this.availabilityContextSequence += 1;
+    return `${this.name}:availability:${Date.now()}:${this.availabilityContextSequence}`;
+  }
+  buildAvailabilityProjectionKey(contextId, version) {
+    return `${contextId}:${version}`;
+  }
+  getAvailabilityRuntimeOffsetMinutes() {
+    if (this.availabilityRuntimeOffsetMinutes === null) {
+      this.availabilityRuntimeOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)();
+    }
+    return this.availabilityRuntimeOffsetMinutes;
+  }
+  getAvailabilityRuntimeDateTime(value = new Date()) {
+    return (0, _localClock.formatLocalDateTime)((0, _localClock.localDateToScalar)(value), this.getAvailabilityRuntimeOffsetMinutes());
+  }
+  cloneAvailabilityPrepareParams(params) {
+    return (0, _lodashEs.cloneDeep)({
+      ...params,
+      productIds: params.productIds ? [...params.productIds] : undefined,
+      resourceIds: params.resourceIds ? [...params.resourceIds] : undefined,
+      rawProducts: params.rawProducts ? (0, _lodashEs.cloneDeep)(params.rawProducts) : undefined,
+      rawResources: params.rawResources ? (0, _lodashEs.cloneDeep)(params.rawResources) : undefined,
+      rawOccupancies: params.rawOccupancies ? (0, _lodashEs.cloneDeep)(params.rawOccupancies) : undefined,
+      editingProductLineUids: params.editingProductLineUids ? [...params.editingProductLineUids] : undefined,
+      dateRange: params.dateRange ? {
+        ...params.dateRange
+      } : undefined,
+      businessHours: params.businessHours ? {
+        ...params.businessHours
+      } : undefined,
+      _availabilityOperatingHours: params._availabilityOperatingHours ? {
+        source: params._availabilityOperatingHours.source,
+        scheduleIds: [...params._availabilityOperatingHours.scheduleIds]
+      } : undefined,
+      catalogScope: params.catalogScope?.type === 'schedule' ? {
+        ...params.catalogScope
+      } : params.catalogScope?.type === 'productList' ? {
+        type: 'productList',
+        params: {
+          ...params.catalogScope.params
+        }
+      } : undefined
+    });
+  }
+  getAvailabilityDurationCandidateAnchorAt(projection) {
+    const value = projection?.meta.durationCandidateAnchorAt;
+    return typeof value === 'string' && value.trim() ? value : undefined;
+  }
+  createAvailabilityContextRef(context) {
+    return {
+      contextId: context.contextId
+    };
+  }
+  async emitAvailabilityDiagnostic(payload) {
+    await this.core?.effects?.emit?.(`${this.name}:${_types.UnifiedBookingSalesHooks.onAvailabilityProjectionDiagnostic}`, {
+      ...payload,
+      registrySize: this.availabilityContextRegistry.size,
+      projectionPoolSize: this.availabilityProjectionPool.size
+    });
+  }
+  touchAvailabilityContext(context) {
+    context.lastAccessedAt = new Date().toISOString();
+    this.availabilityContextRegistry.delete(context.contextId);
+    this.availabilityContextRegistry.set(context.contextId, context);
+  }
+  touchAvailabilityProjection(entry) {
+    this.availabilityProjectionPool.delete(entry.projectionKey);
+    this.availabilityProjectionPool.set(entry.projectionKey, entry);
+    return entry;
+  }
+  removeAvailabilityProjection(projectionKey) {
+    if (!projectionKey) return;
+    this.availabilityProjectionPool.delete(projectionKey);
+  }
+  removeAvailabilityContext(contextId) {
+    const context = this.availabilityContextRegistry.get(contextId);
+    if (!context) return;
+    this.removeAvailabilityProjection(context.activeProjectionKey);
+    this.availabilityProjectionRefreshInFlight.delete(contextId);
+    this.availabilityCommitLocks.delete(contextId);
+    this.availabilityContextRegistry.delete(contextId);
+  }
+  evictAvailabilityProjectionPool() {
+    while (this.availabilityProjectionPool.size > MAX_AVAILABILITY_PROJECTION_POOL) {
+      const oldestEntry = this.availabilityProjectionPool.entries().next().value;
+      if (!oldestEntry) break;
+      const [projectionKey, projectionEntry] = oldestEntry;
+      this.availabilityProjectionPool.delete(projectionKey);
+      const context = this.availabilityContextRegistry.get(projectionEntry.contextId);
+      if (context?.activeProjectionKey === projectionKey) {
+        context.activeProjectionKey = null;
+        context.refreshNonce += 1;
+      }
+    }
+  }
+  evictAvailabilityContextRegistry() {
+    while (this.availabilityContextRegistry.size > MAX_AVAILABILITY_CONTEXT_REGISTRY) {
+      const oldestContext = this.availabilityContextRegistry.entries().next().value;
+      if (!oldestContext) break;
+      this.removeAvailabilityContext(oldestContext[0]);
+    }
+  }
+  invalidateAvailabilityContextsAfterCommit() {
+    this.availabilityLifecycleGeneration += 1;
+    const nextOrderRevision = this.getCurrentOrderRevision();
+    this.availabilityProjectionPool.clear();
+    this.availabilityPrepareInFlight.clear();
+    this.availabilityProjectionRefreshInFlight.clear();
+    this.availabilityContextRegistry.forEach(context => {
+      context.activeVersion += 1;
+      context.activeProjectionKey = null;
+      context.lastKnownOrderRevision = nextOrderRevision;
+      context.refreshNonce += 1;
+      context.lifecycleGeneration = this.availabilityLifecycleGeneration;
+    });
+  }
+  async resetAvailabilityProjectionState(action) {
+    this.availabilityLifecycleGeneration += 1;
+    this.availabilityContextRegistry.clear();
+    this.availabilityProjectionPool.clear();
+    this.availabilityPrepareInFlight.clear();
+    this.availabilityProjectionRefreshInFlight.clear();
+    this.availabilityCommitLocks.clear();
+    this.clearAvailabilityRemoteResourceState();
+    await this.emitAvailabilityDiagnostic({
+      action,
+      contextId: null,
+      contextVersion: null,
+      reason: action,
+      projection: null
+    });
+  }
+  isSessionStoragePersistEnabled() {
+    return Boolean(this.cacheId && this.otherParams?.enableSessionStoragePersist === true);
+  }
+  shouldUseSessionStorageForSubModule(moduleName) {
+    return this.isSessionStoragePersistEnabled() && moduleName === 'order';
+  }
+
+  /**
+   * 读取与当前 cacheId 同分桶的 Solution 会话状态。
+   * 该状态独立于 otherParams，适合页面皮肤保存短生命周期 UI 状态。
+   */
+  getSessionStateValue(key) {
+    if (!key || !this.isSessionStoragePersistEnabled()) return undefined;
+    const cacheData = this.readSessionCacheData();
+    const solutionCache = cacheData?.[this.name];
+    if (!isRecord(solutionCache) || !isRecord(solutionCache.sessionState)) {
+      return undefined;
+    }
+    return solutionCache.sessionState[key];
+  }
+
+  /**
+   * 写入与当前 cacheId 同分桶的 Solution 会话状态。
+   * value 为 undefined 时删除该 key；存储失败不阻断业务流程。
+   */
+  setSessionStateValue(key, value) {
+    if (!key || !this.isSessionStoragePersistEnabled()) return;
+    const cacheData = this.readSessionCacheData();
+    const solutionCache = cacheData?.[this.name];
+    const currentSessionState = isRecord(solutionCache) && isRecord(solutionCache.sessionState) ? solutionCache.sessionState : {};
+    const nextSessionState = {
+      ...currentSessionState
+    };
+    if (value === undefined) {
+      delete nextSessionState[key];
+    } else {
+      nextSessionState[key] = value;
+    }
+    this.checkSaveCache({
+      cacheId: this.cacheId,
+      fatherModule: this.name,
+      store: {
+        sessionState: nextSessionState
+      },
+      cacheKey: ['sessionState']
     });
   }
 
@@ -525,12 +1561,9 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     return 1;
   }
   getRegisteredModuleNames() {
-    return [...super.getRegisteredModuleNames(), 'resourcePlanner', 'openData'];
+    return [...super.getRegisteredModuleNames(), 'openData'];
   }
   createSubModule(moduleName) {
-    if (moduleName === 'resourcePlanner') {
-      return new _modules.ResourcePlannerModule(`${this.name}_resourcePlanner`);
-    }
     if (moduleName === 'openData') {
       return new _modules.OpenDataModule(`${this.name}_openData`);
     }
@@ -582,8 +1615,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     return true;
   }
   isAuthenticatedCustomerUserPlatform() {
-    const platform = String(this.otherParams?.platform || '').toLowerCase();
-    return platform === 'pc' || platform === 'h5';
+    return (0, _platform.isCustomerUserPlatform)(this.otherParams?.platform);
   }
   resolveDiscountOrderIdentity(tempOrder) {
     return tempOrder?.order_id || this.store.order?.getOrderIdentity?.()?.orderId || null;
@@ -675,6 +1707,113 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       channel
     });
   }
+  resetAllergyItemRuleState() {
+    this.allergyItemRuleConfigs = [];
+    this.allergyItemRuleConfigsPromise = null;
+    this.allergyItemRuleEvaluator.setStrategyConfigs([]);
+  }
+  async fetchAllergyItemRuleConfigs(strategyModelIds) {
+    if (!strategyModelIds.length) return [];
+    try {
+      const response = await this.request.get('/promotion', {
+        skip: 1,
+        num: 99,
+        status: 'active',
+        ids: strategyModelIds
+      });
+      if (response?.code !== 200 || !Array.isArray(response?.data?.list)) {
+        throw new Error('[UnifiedBookingSales] 商品过敏策略加载失败');
+      }
+      const list = response.data.list;
+      return normalizeItemRuleStrategyConfigs(list.map(item => item?.metadata));
+    } catch (error) {
+      // this.logMethodError('fetchAllergyItemRuleConfigs', error, {
+      //   strategyModelIds,
+      // });
+      throw error;
+    }
+  }
+  async ensureAllergyItemRuleConfigsLoaded() {
+    if (this.allergyItemRuleConfigs.length > 0) {
+      return this.allergyItemRuleConfigs;
+    }
+    if (this.allergyItemRuleConfigsPromise) {
+      return this.allergyItemRuleConfigsPromise;
+    }
+    this.allergyItemRuleConfigsPromise = (async () => {
+      const staticConfigs = normalizeItemRuleStrategyConfigs(this.otherParams?.itemRule?.strategyConfigs);
+      if (staticConfigs.length > 0) {
+        this.allergyItemRuleConfigs = staticConfigs;
+        this.allergyItemRuleEvaluator.setStrategyConfigs(staticConfigs);
+        return staticConfigs;
+      }
+      const openData = await this.getOpenData();
+      const enabled = toConfiguredBoolean(openData?.['sale.enable_item_rules']);
+      const strategyModelIds = normalizePositiveIntegerList(openData?.['sale.enabled_item_rules']);
+      if (!enabled || !strategyModelIds.length) {
+        this.allergyItemRuleEvaluator.setStrategyConfigs([]);
+        return [];
+      }
+      const loaded = await this.fetchAllergyItemRuleConfigs(strategyModelIds);
+      this.allergyItemRuleConfigs = loaded;
+      this.allergyItemRuleEvaluator.setStrategyConfigs(loaded);
+      return loaded;
+    })();
+    return this.allergyItemRuleConfigsPromise;
+  }
+
+  /**
+   * 评估当前渠道与商品是否命中 ALLERGY_CHECK。
+   * 只返回优先级最高 Action 中当前商品 Target 的 dataSource，不跨商品或 Action 合并。
+   */
+  async resolveProductAllergyRequirement(params) {
+    const productId = normalizePositiveInteger(params.productId);
+    if (!productId) return null;
+    const strategyConfigs = await this.ensureAllergyItemRuleConfigsLoaded();
+    if (!strategyConfigs.length) return null;
+    const productVariantId = normalizePositiveInteger(params.productVariantId);
+    const runtimeConfig = this.otherParams?.itemRule || {};
+    const runtimePax = runtimeConfig.pax || {};
+    const cartItems = (this.getOrderProducts?.() || []).map(item => ({
+      product_id: Number(item?.product_id ?? item?.id),
+      product_variant_id: Number(item?.product_variant_id ?? 0) || undefined,
+      quantity: Number(item?.num ?? item?.quantity ?? 0)
+    })).filter(item => Number.isFinite(item.product_id) && item.product_id > 0 && Number.isFinite(item.quantity) && item.quantity > 0);
+    return this.allergyItemRuleEvaluator.getAllergyRequirement({
+      pax: {
+        total: Number(runtimePax.total ?? 0) || 0,
+        adult: Number(runtimePax.adult ?? 0) || 0,
+        child: Number(runtimePax.child ?? 0) || 0
+      },
+      cartItems,
+      serviceType: String(runtimeConfig.serviceType ?? this.otherParams?.serviceType ?? ''),
+      channel: String(params.channel ?? this.otherParams?.channel ?? this.otherParams?.platform ?? ''),
+      currentProduct: {
+        product_id: productId,
+        ...(productVariantId ? {
+          product_variant_id: productVariantId
+        } : {})
+      },
+      submissionIndex: Number(runtimeConfig.submissionIndex ?? 0) || 0,
+      strategyConfigs,
+      custom: runtimeConfig.custom
+    });
+  }
+
+  /**
+   * Load a resource policy without depending on the legacy appointmentBooking solution.
+   */
+  async getProtocol(policyId) {
+    const normalizedPolicyId = String(policyId ?? '').trim();
+    if (!normalizedPolicyId) {
+      throw new Error('[UnifiedBookingSales] getProtocol 需要 policyId');
+    }
+    let policyUrl = 'shop-policy';
+    if (this.otherParams.platform === 'kiosk' || this.otherParams.platform === 'pos' || this.otherParams.platform === 'shop') {
+      policyUrl = 'policy';
+    }
+    return this.request.get(`/${policyUrl}/${encodeURIComponent(normalizedPolicyId)}`);
+  }
 
   /**
    * Loads the product catalog used by both UI and Planner. Schedule data is requested with each
@@ -696,6 +1835,10 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     await this.core.effects.emit(`${this.name}:onProductsLoaded`, result);
     return result;
   }
+  async queryProducts(params = {}) {
+    if (!this.store.products) throw new Error('[UnifiedBookingSales] products 模块未初始化');
+    return this.store.products.queryProducts(params);
+  }
 
   /** Date-first entry point. It delegates protocol details and cache ownership to ScheduleModule. */
   async loadScheduleAvailableDate(params) {
@@ -863,23 +2006,17 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       preferredDiscountFound: preferredDiscountId === undefined || preferredDiscountId === null ? undefined : Boolean(preferredDiscount)
     });
   }
-
-  /** ResourcePlanner is a required child module; fail early instead of producing partial availability. */
-  getPlanner() {
-    if (!this.store.resourcePlanner) {
-      throw new Error('[UnifiedBookingSales] resourcePlanner 模块未初始化');
-    }
-    return this.store.resourcePlanner;
-  }
   buildUnifiedOrderProduct(sourceProduct, ownershipKey, product) {
+    const normalizedProductRaw = product?.raw || {};
+    const quotationShelfId = sourceProduct._extend?.quotation_shelf_id ?? sourceProduct.quotation_shelf_id ?? sourceProduct.metadata?.quotation_shelf_id;
     const orderProduct = this.transformBaseProductToOrderProduct({
       payload: {
         ...sourceProduct,
         id: sourceProduct.id ?? product?.id,
         product_id: sourceProduct.product_id ?? sourceProduct.id ?? product?.id,
         quantity: sourceProduct.quantity ?? sourceProduct.num ?? product?.quantity ?? 1,
-        price: sourceProduct.price ?? product?.price,
-        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? product?.price,
+        price: sourceProduct.price ?? normalizedProductRaw.price,
+        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? normalizedProductRaw.selling_price ?? normalizedProductRaw.price,
         metadata: {
           ...(sourceProduct.metadata || {}),
           [ownershipKey]: true
@@ -888,11 +2025,14 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
       sourceProduct
     });
     if (orderProduct && typeof orderProduct === 'object') {
-      // BaseSales may rebuild metadata from its price source. Stamp ownership after that transform
-      // so each UnifiedBookingSales entry point can replace only its own temporary lines.
+      // BaseSales may rebuild metadata from its price source. Stamp ownership and the selected
+      // quotation shelf after that transform so neither booking adds nor edits lose quote identity.
       orderProduct.metadata = {
         ...(orderProduct.metadata || {}),
-        [ownershipKey]: true
+        [ownershipKey]: true,
+        ...(quotationShelfId !== undefined ? {
+          quotation_shelf_id: quotationShelfId
+        } : {})
       };
     }
     return orderProduct;
@@ -902,7 +2042,7 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
   async removeExistingStagedLines(ownershipKey) {
     const existingLines = (this.getTempOrder()?.products || []).filter(product => product?.metadata?.[ownershipKey] === true);
     if (existingLines.length > 0) {
-      await this.removeProductsFromOrder(existingLines.map(buildPlannerLineIdentity));
+      await this.removeProductsFromOrder(existingLines.map(buildAvailabilityLineIdentity));
     }
   }
   async stageProducts(params, ownershipKey) {
@@ -930,14 +2070,6 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     return this.getTempOrder();
   }
 
-  /**
-   * Adds the current product choice to an otherwise clean planner cart without creating bookings.
-   * This separates "what the customer wants" from the later time/resource confirmation step.
-   */
-  async stagePlannerProducts(params) {
-    return this.stageProducts(params, 'unified_booking_sales');
-  }
-
   /**
    * Adds ordinary retail products without asking ResourcePlanner for booking facts.
    * Its staged lines have separate ownership so planner and retail skins can coexist safely.
@@ -980,59 +2112,194 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     }
     return this.addProductToOrder(orderProduct);
   }
-
-  /** Normalizes caller-provided products or loads the catalog before any resource request is made. */
-  async loadPlannerProducts(params) {
-    if (params.context?.products?.length) return params.context.products;
-    if (params.rawProducts?.length) return params.rawProducts.map(normalizeProductForPlanner);
-    const productIds = params.productIds || params.productLoadParams?.product_ids || [];
-    if (productIds.length > 0 || params.productLoadParams) {
-      await this.loadProducts({
-        ...(params.date ? {
-          schedule_date: params.date
-        } : {}),
-        ...(params.productLoadParams || {}),
-        product_ids: productIds.length ? productIds.map(Number).filter(Number.isFinite) : params.productLoadParams?.product_ids
+  normalizeAvailabilityDateRange(params, timezone) {
+    const today = (0, _localClock.formatLocalDate)((0, _localClock.localDateToScalar)(new Date()));
+    const startDate = params.dateRange?.startDate || today;
+    const endDate = params.dateRange?.endDate || (0, _localClock.formatLocalDate)((0, _localClock.addLocalCalendarDays)((0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(startDate)), 31));
+    let startScalar;
+    let endScalar;
+    try {
+      startScalar = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(startDate));
+      endScalar = (0, _localClock.localDateToScalarStart)((0, _localClock.parseLocalDate)(endDate));
+    } catch (error) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_DATE_RANGE', '日期范围必须是有效的 YYYY-MM-DD 且结束日期不早于开始日期', {
+        dateRange: {
+          startDate,
+          endDate
+        },
+        timezone,
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (endScalar < startScalar) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_DATE_RANGE', '日期范围必须是有效的 YYYY-MM-DD 且结束日期不早于开始日期', {
+        dateRange: {
+          startDate,
+          endDate
+        },
+        timezone
       });
     }
-    return (this.getProductCatalog?.().products || []).map(normalizeProductForPlanner);
+    const inclusiveDays = Math.trunc((endScalar - startScalar) / (24 * 60 * 60 * 1000)) + 1;
+    if (inclusiveDays > MAX_AVAILABILITY_RANGE_DAYS) {
+      throw new _ResourcePlanner.AvailabilityError('RANGE_TOO_LARGE', '日期范围最多包含 90 个自然日', {
+        dateRange: {
+          startDate,
+          endDate
+        },
+        inclusiveDays
+      });
+    }
+    return {
+      startDate,
+      endDate
+    };
   }
-
-  /** Loads the reusable store-level schedule catalog on demand. */
-  async ensurePlannerSchedulesLoaded() {
-    if (!this.store.schedule) throw new Error('[UnifiedBookingSales] schedule 模块未初始化');
-    const scheduleList = this.store.schedule.getScheduleList?.() || [];
-    if (!this.store.schedule.isScheduleListLoaded?.() || scheduleList.length === 0) {
-      await this.store.schedule.loadAllSchedule();
+  assertAvailabilityPrepareParams(params) {
+    assertAvailabilityCatalogProductIds(params.productIds, 'prepare.productIds');
+    const hasProductAnchor = Array.isArray(params.productIds) && params.productIds.length > 0;
+    const hasResourceAnchor = Array.isArray(params.resourceIds) && params.resourceIds.length > 0;
+    const hasDateAnchor = Boolean(params.dateRange?.startDate || params.dateRange?.endDate);
+    if (!hasProductAnchor && !hasResourceAnchor && !hasDateAnchor) {
+      throw new _ResourcePlanner.AvailabilityError('MISSING_ANCHOR', 'prepare 至少需要 productIds、resourceIds 或 dateRange 之一', {
+        params
+      });
+    }
+    if (!hasProductAnchor && !params.catalogScope) {
+      throw new _ResourcePlanner.AvailabilityError('MISSING_CATALOG_SCOPE', '缺少 productIds 时必须提供 catalogScope', {
+        params
+      });
+    }
+    if (params.slotStepMinutes !== undefined) {
+      const step = Number(params.slotStepMinutes);
+      if (!Number.isInteger(step) || step <= 0) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'slotStepMinutes 必须是正整数', {
+          slotStepMinutes: params.slotStepMinutes
+        });
+      }
     }
-    return this.store.schedule.getScheduleList?.() || [];
+  }
+  captureAvailabilityScheduleCatalog() {
+    if (!this.store.schedule) {
+      throw new Error('[UnifiedBookingSales] schedule 模块未初始化');
+    }
+    this.availabilityScheduleCatalog = (0, _lodashEs.cloneDeep)(this.store.schedule.getScheduleList?.() || []);
   }
 
-  /**
-   * v2 resources reference schedule ids rather than expanded work times. Refresh once when the
-   * cached schedule catalog cannot materialize all referenced ids.
-   */
-  async ensurePlannerSchedulesForResources(rawResources) {
-    let scheduleList = await this.ensurePlannerSchedulesLoaded();
-    const scheduleIds = collectRawScheduleIds(rawResources);
-    if (!scheduleListHasIds(scheduleList, scheduleIds)) {
-      await this.store.schedule.loadAllSchedule({
-        useCache: false
+  /** Returns the solution-lifetime schedule snapshot captured after initialization. */
+  getAvailabilityScheduleCatalog() {
+    if (this.availabilityScheduleCatalog === null) {
+      throw new Error('[UnifiedBookingSales] schedule 快照未初始化');
+    }
+    return this.availabilityScheduleCatalog;
+  }
+  buildAvailabilityOperatingHoursSnapshot(params) {
+    const descriptor = params.prepare._availabilityOperatingHours || {
+      source: params.prepare.businessHours ? 'prepare_business_hours' : 'default_business_hours',
+      scheduleIds: []
+    };
+    if (descriptor.source !== 'open_data_schedule') {
+      const windows = dateRangeDays(params.dateRange).flatMap(date => {
+        const range = normalizeAvailabilityLocalDateTimeRange({
+          startAt: `${date}T${params.businessHours.startTime}:00`,
+          endAt: `${date}T${params.businessHours.endTime}:00`,
+          fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes(),
+          rollOverEnd: true
+        });
+        return range ? [{
+          startAt: range.startAt,
+          endAt: range.endAt,
+          source: descriptor.source
+        }] : [];
+      });
+      return {
+        source: descriptor.source,
+        scheduleIds: [],
+        missingScheduleIds: [],
+        windows
+      };
+    }
+    const scheduleMap = new Map(params.scheduleList.map(schedule => [String(schedule.id), schedule]));
+    const schedules = descriptor.scheduleIds.map(scheduleId => scheduleMap.get(String(scheduleId))).filter(schedule => Boolean(schedule));
+    const matchedScheduleIds = new Set(schedules.map(schedule => String(schedule.id)));
+    const missingScheduleIds = descriptor.scheduleIds.filter(scheduleId => !matchedScheduleIds.has(String(scheduleId)));
+    const windows = dateRangeDays(params.dateRange).flatMap(date => (0, _getDateIsInSchedule.getScheduleStartEndTimePoints)(date, schedules).flatMap(slot => {
+      const range = normalizeAvailabilityLocalDateTimeRange({
+        startAt: slot.start_at,
+        endAt: slot.end_at,
+        fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes(),
+        rollOverEnd: true
+      });
+      return range ? [{
+        startAt: range.startAt,
+        endAt: range.endAt,
+        source: `operating_schedule:${descriptor.scheduleIds.map(String).join(',')}`
+      }] : [];
+    }));
+    return {
+      source: descriptor.source,
+      scheduleIds: [...descriptor.scheduleIds],
+      missingScheduleIds,
+      windows
+    };
+  }
+  async loadAvailabilityProducts(params) {
+    const {
+      prepare,
+      dateRange
+    } = params;
+    const explicitProductIds = prepare.productIds || [];
+    let rawProducts = [];
+    if (Array.isArray(prepare.rawProducts)) {
+      rawProducts = prepare.rawProducts;
+      this.unifiedProductCatalog = [...rawProducts];
+    } else if (explicitProductIds.length > 0) {
+      rawProducts = await this.loadProducts({
+        product_ids: explicitProductIds,
+        schedule_date: dateRange.startDate
+      });
+    } else if (prepare.catalogScope?.type === 'schedule') {
+      await this.loadScheduleAvailableDate({
+        startDate: dateRange.startDate,
+        endDate: dateRange.endDate,
+        custom_page_id: Number(prepare.catalogScope.customPageId) || undefined,
+        channel: prepare.catalogScope.channel
+      });
+      const dateSet = new Set(dateRangeDays(dateRange));
+      const scheduleProductIds = (this.store.schedule.getAvailabilityScheduleDateList?.() || []).filter(item => dateSet.has(item.date)).flatMap(item => item.product_ids || []);
+      const productIds = uniqueAvailabilityIds([...scheduleProductIds, ...(this.store.schedule.getOtherProductsIds?.() || [])]);
+      if (productIds.length > 0) {
+        assertAvailabilityCatalogProductIds(productIds, 'prepare.catalogScope.scheduleProductIds');
+        rawProducts = await this.loadProducts({
+          product_ids: productIds,
+          schedule_date: dateRange.startDate
+        });
+      } else {
+        this.unifiedProductCatalog = [];
+      }
+    } else if (prepare.catalogScope?.type === 'productList') {
+      rawProducts = await this.loadProducts({
+        ...prepare.catalogScope.params,
+        schedule_date: prepare.catalogScope.params.schedule_date || dateRange.startDate
       });
-      scheduleList = this.store.schedule.getScheduleList?.() || [];
     }
-    return scheduleList;
+    const normalized = rawProducts.map(product => normalizeProductForAvailability(product, params.scheduleList, this.getAvailabilityRuntimeOffsetMinutes()));
+    if (!explicitProductIds.length && prepare.resourceIds?.length) {
+      return normalized.filter(product => product.requirementGroups?.some(group => group.resourceIds?.some(resourceId => prepare.resourceIds.some(id => sameAvailabilityId(id, resourceId)))));
+    }
+    const productIdSet = explicitProductIds.length ? new Set(explicitProductIds.map(String)) : null;
+    return productIdSet ? normalized.filter(product => productIdSet.has(String(product.id))) : normalized;
   }
 
   /**
    * Fetches resource metadata plus flat occupied events. Work windows are intentionally derived
-   * locally in buildPlannerResourcesFromV2 from /schedule, rather than requested from the legacy
+   * locally in buildAvailabilityResourcesFromV2 from /schedule, rather than requested from the legacy
    * resource dates endpoint.
    */
-  async fetchPlannerResourcesV2(params) {
+  async fetchAvailabilityResourcesV2(params) {
     const response = await this.request.get('/schedule/resource/list/v2', {
-      start_date: params.dateRange.start,
-      end_date: params.dateRange.end,
+      start_date: params.dateRange.startDate,
+      end_date: params.dateRange.endDate,
       resource_ids: params.resourceIds,
       front_end_cache_id: false
     }, {
@@ -1043,180 +2310,1081 @@ class UnifiedBookingSalesImpl extends _BookingTicket.BookingTicket {
     if (Array.isArray(data?.list)) return data.list;
     return [];
   }
-
-  /**
-   * Resolves the Planner context in precedence order: explicit normalized context, test raw data,
-   * then the v2 resource API inferred from selected product requirements and any URL lock.
-   */
-  async loadPlannerResources(params, products = []) {
-    if (params.context?.resources?.length) {
-      return {
-        resources: params.context.resources,
-        externalEvents: params.context.externalEvents || []
-      };
+  async fetchAndPublishAvailabilityResourcesV2(params) {
+    const normalizedResourceIds = this.normalizeAvailabilityIdList(params.resourceIds) || [];
+    if (normalizedResourceIds.length === 0) return [];
+    const scopeKey = this.buildAvailabilityRemoteResourceScopeKey(params.timezone);
+    const cacheParams = {
+      scopeKey,
+      resourceIds: normalizedResourceIds,
+      dateRange: params.dateRange
+    };
+    const cachedRawResources = this.availabilityRemoteOccupancyCache.read(cacheParams);
+    if (cachedRawResources) {
+      if (params.useCacheOnHit) {
+        void this.refreshAvailabilityRemoteResourceQuery({
+          timezone: params.timezone,
+          dateRange: params.dateRange,
+          resourceIds: normalizedResourceIds
+        }).catch(error => {
+          console.warn('[UnifiedBookingSales] Remote occupancy background refresh failed', error);
+        });
+      }
+      return cachedRawResources;
+    }
+    return await this.refreshAvailabilityRemoteResourceQuery({
+      timezone: params.timezone,
+      dateRange: params.dateRange,
+      resourceIds: normalizedResourceIds
+    });
+  }
+  async refreshAvailabilityRemoteResourceQuery(params) {
+    const normalizedResourceIds = this.normalizeAvailabilityIdList(params.resourceIds) || [];
+    if (normalizedResourceIds.length === 0) return [];
+    const queryKey = this.buildAvailabilityRemoteResourceQueryKey({
+      timezone: params.timezone,
+      dateRange: params.dateRange,
+      resourceIds: normalizedResourceIds
+    });
+    const epoch = this.availabilityRemoteResourceEpoch;
+    const existing = this.availabilityRemoteResourceQueryInFlight.get(queryKey);
+    if (existing?.epoch === epoch) {
+      return await existing.promise;
+    }
+    this.availabilityRemoteResourceQuerySequence += 1;
+    const writeVersion = this.availabilityRemoteResourceQuerySequence;
+    const promise = this.fetchAvailabilityResourcesV2({
+      dateRange: params.dateRange,
+      resourceIds: normalizedResourceIds
+    });
+    this.availabilityRemoteResourceQueryInFlight.set(queryKey, {
+      epoch,
+      promise
+    });
+    try {
+      const rawResources = await promise;
+      if (epoch === this.availabilityRemoteResourceEpoch) {
+        this.availabilityRemoteOccupancyCache.publish({
+          scopeKey: this.buildAvailabilityRemoteResourceScopeKey(params.timezone),
+          timezoneName: params.timezone,
+          resourceIds: normalizedResourceIds,
+          dateRange: params.dateRange,
+          rawResources,
+          version: writeVersion
+        });
+      }
+      return rawResources;
+    } finally {
+      const current = this.availabilityRemoteResourceQueryInFlight.get(queryKey);
+      if (current?.promise === promise) {
+        this.availabilityRemoteResourceQueryInFlight.delete(queryKey);
+      }
     }
-    if (params.rawResources?.length) {
+  }
+  async loadAvailabilityResources(params) {
+    const resourceIds = collectAvailabilityResourceIds(params.products, params.resourceIds || []);
+    if (resourceIds.length === 0) {
       return {
-        resources: params.rawResources.map(normalizeResource).filter(resource => resource !== null),
-        externalEvents: params.context?.externalEvents || []
+        resources: [],
+        resourceOccupancies: []
       };
     }
-    const resourceIds = collectPlannerResourceIds(products, params.resourceIds || []);
-    if (!params.useResourceDateApi || !params.dateRange || resourceIds.length === 0) {
-      return {
+    if (Array.isArray(params.rawResources)) {
+      return buildAvailabilityResourcesFromV2({
+        rawResources: params.rawResources,
+        scheduleList: params.scheduleList,
+        dateRange: params.dateRange,
+        fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes()
+      });
+    }
+    if (params.fetchPolicy === 'cache_only') {
+      const cachedRawResources = this.availabilityRemoteOccupancyCache.read({
+        scopeKey: this.buildAvailabilityRemoteResourceScopeKey(params.timezone),
+        resourceIds,
+        dateRange: params.dateRange
+      });
+      if (cachedRawResources) {
+        return buildAvailabilityResourcesFromV2({
+          rawResources: cachedRawResources,
+          scheduleList: params.scheduleList,
+          dateRange: params.dateRange,
+          fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes()
+        });
+      }
+      return params.fallbackResources ? (0, _lodashEs.cloneDeep)(params.fallbackResources) : {
         resources: [],
-        externalEvents: params.context?.externalEvents || []
+        resourceOccupancies: []
       };
     }
-    const rawResources = await this.fetchPlannerResourcesV2({
+    const rawResources = await this.fetchAndPublishAvailabilityResourcesV2({
+      timezone: params.timezone,
       dateRange: params.dateRange,
-      resourceIds
+      resourceIds,
+      useCacheOnHit: true
     });
-    const scheduleList = await this.ensurePlannerSchedulesForResources(rawResources);
-    const materialized = buildPlannerResourcesFromV2({
+    return buildAvailabilityResourcesFromV2({
       rawResources,
-      scheduleList,
-      dateRange: params.dateRange
+      scheduleList: params.scheduleList,
+      dateRange: params.dateRange,
+      fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes()
+    });
+  }
+  resolveEditingOccupancyExclusions(tempOrder, productLineUids = []) {
+    const productUids = new Set();
+    const bookingUids = new Set();
+    const scheduleEventIds = new Set();
+    if (!productLineUids.length) return {
+      productUids,
+      bookingUids,
+      scheduleEventIds
+    };
+    const products = Array.isArray(tempOrder?.products) ? tempOrder.products : [];
+    const bookings = Array.isArray(tempOrder?.bookings) ? tempOrder.bookings : [];
+    productLineUids.forEach(requestedUid => {
+      const product = products.find(line => getProductLineUid(line) === String(requestedUid));
+      if (!product) {
+        throw new _ResourcePlanner.AvailabilityError('SELF_EXCLUSION_RESOLVE_FAILED', '无法解析编辑商品行，不能安全排除自身占用', {
+          productLineUid: requestedUid
+        });
+      }
+      const productUid = getProductLineUid(product);
+      const linkedBookingUid = String(product.booking_uid ?? product.metadata?.booking_uid ?? '');
+      const linkedBookings = bookings.filter(booking => linkedBookingUid && getBookingUid(booking) === linkedBookingUid || productUid && String(booking.product_uid ?? '') === productUid);
+      if (!productUid || !linkedBookings.length) {
+        throw new _ResourcePlanner.AvailabilityError('SELF_EXCLUSION_RESOLVE_FAILED', '编辑商品行缺少可验证的 booking 关联', {
+          productLineUid: requestedUid,
+          linkedBookingUid
+        });
+      }
+      productUids.add(productUid);
+      linkedBookings.forEach(booking => {
+        const bookingUid = getBookingUid(booking);
+        if (bookingUid) bookingUids.add(bookingUid);
+        if (booking.schedule_event_id != null) {
+          scheduleEventIds.add(String(booking.schedule_event_id));
+        }
+      });
     });
     return {
-      resources: materialized.resources,
-      externalEvents: [...(params.context?.externalEvents || []), ...materialized.externalEvents]
+      productUids,
+      bookingUids,
+      scheduleEventIds
     };
   }
-
-  /**
-   * Boundary between IO and pure planning. Once this returns, all later availability/slot calls
-   * operate on the ResourcePlanner snapshot and do not issue resource requests themselves.
-   */
-  async loadPlannerContext(params = {}) {
-    const products = await this.loadPlannerProducts(params);
-    const plannerResources = await this.loadPlannerResources(params, products);
-    const context = {
-      ...(params.context || {}),
+  occupancyIsExcluded(occupancy, exclusions) {
+    if (occupancy.scheduleEventId != null) {
+      return exclusions.scheduleEventIds.has(String(occupancy.scheduleEventId));
+    }
+    if (occupancy.bookingUid != null) {
+      return exclusions.bookingUids.has(String(occupancy.bookingUid));
+    }
+    if (occupancy.productUid != null) {
+      return exclusions.productUids.has(String(occupancy.productUid));
+    }
+    return false;
+  }
+  collectCartResourceOccupancies(tempOrder, exclusions) {
+    const bookings = Array.isArray(tempOrder?.bookings) ? tempOrder.bookings : [];
+    return bookings.flatMap(booking => {
+      const bookingUid = getBookingUid(booking);
+      const productUid = String(booking.product_uid ?? booking.metadata?.product_uid ?? '');
+      const scheduleEventId = toNumberId(booking.schedule_event_id);
+      const startAt = booking.start_at || `${booking.start_date || ''} ${booking.start_time || ''}`.trim();
+      const endAt = booking.end_at || `${booking.end_date || booking.start_date || ''} ${booking.end_time || ''}`.trim();
+      const resources = Array.isArray(booking.resources) ? booking.resources : [];
+      return resources.flatMap(resource => {
+        const resourceId = resource.resource_id ?? resource.relation_id ?? resource.id;
+        if (resourceId == null || !startAt || !endAt) return [];
+        const range = normalizeAvailabilityLocalDateTimeRange({
+          startAt,
+          endAt,
+          fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes(),
+          rollOverEnd: false
+        });
+        if (!range) return [];
+        const occupancy = {
+          resourceId,
+          startAt: range.startAt,
+          endAt: range.endAt,
+          pax: Math.max(1, Number(resource.capacity ?? booking.capacity ?? 1) || 1),
+          source: 'cart',
+          scheduleEventId,
+          bookingUid: bookingUid || undefined,
+          productUid: productUid || undefined,
+          raw: {
+            booking,
+            resource
+          }
+        };
+        return this.occupancyIsExcluded(occupancy, exclusions) ? [] : [occupancy];
+      });
+    });
+  }
+  getCurrentOrderRevision() {
+    return resolveOrderRevision(this.getTempOrder());
+  }
+  getAvailabilityContextEntry(contextId) {
+    const context = this.availabilityContextRegistry.get(contextId);
+    if (!context) {
+      throw this.createAvailabilityFacadeError('AVAILABILITY_CONTEXT_NOT_FOUND', 'availability context 不存在或已失效，请重新 prepare', {
+        contextId,
+        lifecycleGeneration: this.availabilityLifecycleGeneration
+      });
+    }
+    this.touchAvailabilityContext(context);
+    return context;
+  }
+  getAvailabilityProjectionByKey(projectionKey) {
+    if (!projectionKey) return null;
+    return this.availabilityProjectionPool.get(projectionKey)?.projection || null;
+  }
+  getActiveAvailabilityProjectionEntry(context) {
+    if (!context.activeProjectionKey) return null;
+    const entry = this.availabilityProjectionPool.get(context.activeProjectionKey);
+    if (!entry) return null;
+    return this.touchAvailabilityProjection(entry);
+  }
+  decorateAvailabilityCandidate(contextId, contextVersion, candidate) {
+    return {
+      ...candidate,
+      availabilityContextId: contextId,
+      availabilityContextVersion: contextVersion
+    };
+  }
+  assertAvailabilityCandidateFreshness(context, candidate) {
+    if (candidate.availabilityContextId !== context.contextId) {
+      throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '候选与 availability context 不匹配，请重新获取候选', {
+        candidateContextId: candidate.availabilityContextId,
+        contextId: context.contextId
+      });
+    }
+    const currentContextVersion = context.activeVersion;
+    if (candidate.availabilityContextVersion !== currentContextVersion) {
+      throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '候选已过期，请重新获取最新时间段', {
+        contextId: context.contextId,
+        candidateContextVersion: candidate.availabilityContextVersion,
+        currentContextVersion,
+        snapshotId: context.lastSnapshotId
+      });
+    }
+  }
+  assertContextualQueryFreshness(context, request) {
+    if (request.target === 'time') {
+      request.candidates.forEach(candidate => {
+        this.assertAvailabilityCandidateFreshness(context, candidate);
+      });
+      return;
+    }
+    if (request.target === 'resource') {
+      request.selectedRanges.forEach(candidate => {
+        this.assertAvailabilityCandidateFreshness(context, candidate);
+      });
+    }
+  }
+  storeAvailabilityProjectionEntry(params) {
+    const previousContext = this.availabilityContextRegistry.get(params.contextId);
+    const contextVersion = previousContext ? previousContext.activeVersion + (params.incrementVersion ? 1 : 0) : 1;
+    const projectionKey = this.buildAvailabilityProjectionKey(params.contextId, contextVersion);
+    const entry = {
+      contextId: params.contextId,
+      contextVersion,
+      projectionKey,
+      projection: params.projection,
+      orderRevision: params.orderRevision,
+      preparedAt: params.projection.meta.preparedAt,
+      snapshotId: params.projection.meta.snapshotId
+    };
+    if (previousContext?.activeProjectionKey && previousContext.activeProjectionKey !== projectionKey) {
+      this.removeAvailabilityProjection(previousContext.activeProjectionKey);
+    }
+    this.availabilityProjectionPool.set(projectionKey, entry);
+    this.evictAvailabilityProjectionPool();
+    const nextContext = {
+      contextId: params.contextId,
+      prepareParams: this.cloneAvailabilityPrepareParams(params.prepareParams),
+      prepareKey: params.prepareKey,
+      activeVersion: contextVersion,
+      activeProjectionKey: projectionKey,
+      createdAt: previousContext?.createdAt ?? params.projection.meta.preparedAt,
+      lastAccessedAt: new Date().toISOString(),
+      lastKnownOrderRevision: params.orderRevision,
+      lastPreparedAt: params.projection.meta.preparedAt,
+      lastSnapshotId: params.projection.meta.snapshotId,
+      durationCandidateAnchorAt: previousContext?.durationCandidateAnchorAt ?? this.getAvailabilityDurationCandidateAnchorAt(params.projection),
+      refreshNonce: previousContext?.refreshNonce ?? 0,
+      lifecycleGeneration: this.availabilityLifecycleGeneration
+    };
+    this.touchAvailabilityContext(nextContext);
+    this.evictAvailabilityContextRegistry();
+    return this.touchAvailabilityProjection(entry);
+  }
+  async buildAvailabilityProjectionSnapshot(params, options = {}) {
+    const normalizedPrepareParams = this.normalizeAvailabilityPrepareDescriptor(params);
+    const timezoneLabel = String(normalizedPrepareParams.timezone);
+    const dateRange = normalizedPrepareParams.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,
+      scheduleList,
+      businessHours
+    });
+    const products = await this.loadAvailabilityProducts({
+      prepare: normalizedPrepareParams,
+      dateRange,
+      scheduleList
+    });
+    const loadedResources = await this.loadAvailabilityResources({
+      timezone: timezoneLabel,
+      dateRange,
+      resourceIds: normalizedPrepareParams.resourceIds,
       products,
-      resources: plannerResources.resources,
-      externalEvents: plannerResources.externalEvents
+      rawResources: normalizedPrepareParams.rawResources,
+      scheduleList,
+      fetchPolicy: options.resourceFetchPolicy || 'default',
+      fallbackResources: options.fallbackResources
+    });
+    const tempOrder = this.getTempOrder();
+    const exclusions = this.resolveEditingOccupancyExclusions(tempOrder, normalizedPrepareParams.editingProductLineUids);
+    const injectedRawOccupancies = (normalizedPrepareParams.rawOccupancies || []).flatMap(occupancy => {
+      const range = normalizeAvailabilityLocalDateTimeRange({
+        startAt: occupancy.startAt,
+        endAt: occupancy.endAt,
+        fixedOffsetMinutes: this.getAvailabilityRuntimeOffsetMinutes(),
+        rollOverEnd: false
+      });
+      if (!range) return [];
+      return [{
+        ...occupancy,
+        startAt: range.startAt,
+        endAt: range.endAt
+      }];
+    });
+    const remoteOccupancies = [...loadedResources.resourceOccupancies, ...(loadedResources.includesInjectedRawOccupancies ? [] : injectedRawOccupancies)].filter(occupancy => !this.occupancyIsExcluded(occupancy, exclusions));
+    const cartOccupancies = this.collectCartResourceOccupancies(tempOrder, exclusions);
+    const preparedAt = this.getAvailabilityRuntimeDateTime();
+    const durationCandidateAnchorAt = options.durationCandidateAnchorAt || preparedAt;
+    this.availabilityProjectionSequence += 1;
+    const orderRevision = this.getCurrentOrderRevision();
+    const projection = (0, _ResourcePlanner.createAvailabilityProjection)({
+      products,
+      resources: loadedResources.resources,
+      resourceOccupancies: [...remoteOccupancies, ...cartOccupancies],
+      mode,
+      timezone: timezoneLabel,
+      coverage: dateRange,
+      slotStepMinutes,
+      businessHours,
+      operatingHours,
+      preparedAt,
+      now: preparedAt,
+      orderRevision,
+      snapshotId: `${this.name}:${Date.now()}:${this.availabilityProjectionSequence}`,
+      anchors: {
+        productIds: normalizedPrepareParams.productIds,
+        resourceIds: normalizedPrepareParams.resourceIds,
+        dateRange
+      },
+      prepareParams: normalizedPrepareParams,
+      durationCandidateAnchorAt
+    });
+    return {
+      projection,
+      prepareParams: normalizedPrepareParams,
+      orderRevision
     };
-    const snapshot = this.getPlanner().setContext(context);
-    this.getPlanner().setSelectionPatch({
-      mode: params.mode,
-      productIds: params.productIds || [],
-      date: params.date,
-      startTime: params.startTime,
-      endTime: params.endTime,
-      resourceIds: params.resourceIds || []
+  }
+  async getSharedPreparedAvailabilitySnapshot(params) {
+    const lifecycleGeneration = this.availabilityLifecycleGeneration;
+    const normalizedParams = this.normalizeAvailabilityPrepareDescriptor(params);
+    const hasRawInputs = params.rawProducts !== undefined || params.rawResources !== undefined || params.rawOccupancies !== undefined;
+    const prepareKey = hasRawInputs ? JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      prepare: {
+        ...normalizedParams,
+        rawProducts: undefined,
+        rawResources: undefined,
+        rawOccupancies: undefined
+      },
+      rawInputs: {
+        products: params.rawProducts !== undefined,
+        resources: params.rawResources !== undefined,
+        occupancies: params.rawOccupancies !== undefined
+      }
+    })) : this.buildAvailabilityPrepareKey(normalizedParams);
+    if (hasRawInputs) {
+      const snapshot = await this.buildAvailabilityProjectionSnapshot(normalizedParams);
+      if (lifecycleGeneration !== this.availabilityLifecycleGeneration) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_CONTEXT_NOT_FOUND', 'prepare 期间业务作用域或实例生命周期已变化，请重新 prepare', {
+          prepareKey,
+          expectedLifecycleGeneration: lifecycleGeneration,
+          currentLifecycleGeneration: this.availabilityLifecycleGeneration
+        });
+      }
+      return {
+        prepareKey,
+        snapshot
+      };
+    }
+    const existing = this.availabilityPrepareInFlight.get(prepareKey);
+    const promise = existing?.lifecycleGeneration === lifecycleGeneration ? existing.promise : this.buildAvailabilityProjectionSnapshot(normalizedParams);
+    if (!existing || existing.lifecycleGeneration !== lifecycleGeneration) {
+      this.availabilityPrepareInFlight.set(prepareKey, {
+        lifecycleGeneration,
+        prepareKey,
+        promise
+      });
+    }
+    try {
+      const snapshot = await promise;
+      if (lifecycleGeneration !== this.availabilityLifecycleGeneration) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_CONTEXT_NOT_FOUND', 'prepare 期间业务作用域或实例生命周期已变化，请重新 prepare', {
+          prepareKey,
+          expectedLifecycleGeneration: lifecycleGeneration,
+          currentLifecycleGeneration: this.availabilityLifecycleGeneration
+        });
+      }
+      return {
+        prepareKey,
+        snapshot
+      };
+    } finally {
+      const current = this.availabilityPrepareInFlight.get(prepareKey);
+      if (current?.promise === promise) {
+        this.availabilityPrepareInFlight.delete(prepareKey);
+      }
+    }
+  }
+  async refreshAvailabilityContextProjection(params) {
+    const existingInFlight = this.availabilityProjectionRefreshInFlight.get(params.contextId);
+    if (existingInFlight) return await existingInFlight;
+    const context = this.getAvailabilityContextEntry(params.contextId);
+    const expectedVersion = context.activeVersion;
+    const expectedRefreshNonce = context.refreshNonce;
+    const expectedLifecycleGeneration = this.availabilityLifecycleGeneration;
+    const refreshPromise = (async () => {
+      const snapshot = await this.buildAvailabilityProjectionSnapshot(this.cloneAvailabilityPrepareParams(context.prepareParams), {
+        durationCandidateAnchorAt: context.durationCandidateAnchorAt
+      });
+      const currentContext = this.availabilityContextRegistry.get(params.contextId);
+      if (!currentContext) return null;
+      if (expectedLifecycleGeneration !== this.availabilityLifecycleGeneration || currentContext.activeVersion !== expectedVersion || currentContext.refreshNonce !== expectedRefreshNonce || currentContext.lifecycleGeneration !== expectedLifecycleGeneration) {
+        return null;
+      }
+      const projectionEntry = this.storeAvailabilityProjectionEntry({
+        contextId: currentContext.contextId,
+        prepareParams: snapshot.prepareParams,
+        prepareKey: currentContext.prepareKey,
+        projection: snapshot.projection,
+        orderRevision: snapshot.orderRevision,
+        incrementVersion: true
+      });
+      await this.emitAvailabilityDiagnostic({
+        action: 'refresh',
+        contextId: currentContext.contextId,
+        contextVersion: projectionEntry.contextVersion,
+        projection: projectionEntry.projection,
+        snapshotId: projectionEntry.snapshotId,
+        orderRevision: projectionEntry.orderRevision,
+        previousOrderRevision: params.previousOrderRevision,
+        reason: params.reason
+      });
+      return projectionEntry;
+    })();
+    this.availabilityProjectionRefreshInFlight.set(params.contextId, refreshPromise);
+    try {
+      return await refreshPromise;
+    } finally {
+      const current = this.availabilityProjectionRefreshInFlight.get(params.contextId);
+      if (current === refreshPromise) {
+        this.availabilityProjectionRefreshInFlight.delete(params.contextId);
+      }
+    }
+  }
+  async ensureAvailabilityContextProjection(contextId, reason) {
+    let retries = 0;
+    while (retries < 3) {
+      const context = this.getAvailabilityContextEntry(contextId);
+      const currentOrderRevision = this.getCurrentOrderRevision();
+      const projectionEntry = this.getActiveAvailabilityProjectionEntry(context);
+      if (projectionEntry && projectionEntry.orderRevision === currentOrderRevision) {
+        return {
+          context,
+          projectionEntry,
+          refreshed: false
+        };
+      }
+      const refreshedProjectionEntry = await this.refreshAvailabilityContextProjection({
+        contextId,
+        reason: projectionEntry ? reason : `${reason}:projection_cache_miss`,
+        previousOrderRevision: context.lastKnownOrderRevision
+      });
+      if (!refreshedProjectionEntry) {
+        retries += 1;
+        continue;
+      }
+      if (refreshedProjectionEntry.orderRevision !== this.getCurrentOrderRevision()) {
+        retries += 1;
+        continue;
+      }
+      return {
+        context: this.getAvailabilityContextEntry(contextId),
+        projectionEntry: refreshedProjectionEntry,
+        refreshed: true
+      };
+    }
+    throw new _ResourcePlanner.AvailabilityError('STALE_PROJECTION', 'availability projection 刷新期间购物车持续变化，请重新 prepare', {
+      contextId,
+      reason
     });
-    await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onPlannerContextLoaded}`, snapshot);
-    return this.getPlanner().getSnapshot();
   }
-
-  /** Returns cells, date summaries and a derived grid; cells are continuous ranges, not UI slots. */
-  async queryPlannerAvailability(query = {}) {
-    return this.getPlanner().queryAvailability(query);
+  async tryAcquireAvailabilityCommitLock(contextId) {
+    if (this.availabilityCommitLocks.has(contextId)) {
+      const waitingContext = this.availabilityContextRegistry.get(contextId);
+      await this.emitAvailabilityDiagnostic({
+        action: 'commit_lock_wait',
+        contextId,
+        contextVersion: waitingContext?.activeVersion ?? null,
+        projection: this.getAvailabilityProjectionByKey(waitingContext?.activeProjectionKey),
+        snapshotId: waitingContext?.lastSnapshotId,
+        orderRevision: waitingContext?.lastKnownOrderRevision,
+        reason: 'AVAILABILITY_COMMIT_IN_PROGRESS'
+      });
+      throw this.createAvailabilityFacadeError('AVAILABILITY_COMMIT_IN_PROGRESS', '同一 availability context 已有 commit 正在进行中', {
+        contextId
+      });
+    }
+    this.availabilityCommitLocks.add(contextId);
+    const currentContext = this.availabilityContextRegistry.get(contextId);
+    await this.emitAvailabilityDiagnostic({
+      action: 'commit_lock_acquired',
+      contextId,
+      contextVersion: currentContext?.activeVersion ?? null,
+      projection: this.getAvailabilityProjectionByKey(currentContext?.activeProjectionKey),
+      snapshotId: currentContext?.lastSnapshotId,
+      orderRevision: currentContext?.lastKnownOrderRevision,
+      reason: 'commit_start'
+    });
+  }
+  async releaseAvailabilityCommitLock(contextId) {
+    this.availabilityCommitLocks.delete(contextId);
+    const releasedContext = this.availabilityContextRegistry.get(contextId);
+    await this.emitAvailabilityDiagnostic({
+      action: 'commit_lock_released',
+      contextId,
+      contextVersion: releasedContext?.activeVersion ?? null,
+      projection: this.getAvailabilityProjectionByKey(releasedContext?.activeProjectionKey),
+      snapshotId: releasedContext?.lastSnapshotId,
+      orderRevision: releasedContext?.lastKnownOrderRevision,
+      reason: 'commit_end'
+    });
   }
 
-  /** Turns compatible availability ranges into user-selectable intervals and ready-to-commit assignments. */
-  resolveAssignableSlots(query = {}) {
-    return this.getPlanner().resolveAssignableSlots(query);
+  /** IO boundary: loads catalog, schedules, resources, occupancies, and registers one context. */
+  async prepareAvailabilityProjection(params) {
+    this.assertAvailabilityPrepareParams(params);
+    const paramsWithDefaults = await this.resolveAvailabilityPrepareDefaults(params);
+    const {
+      prepareKey,
+      snapshot
+    } = await this.getSharedPreparedAvailabilitySnapshot(paramsWithDefaults);
+    const contextId = this.createAvailabilityContextId();
+    const projectionEntry = this.storeAvailabilityProjectionEntry({
+      contextId,
+      prepareParams: snapshot.prepareParams,
+      prepareKey,
+      projection: snapshot.projection,
+      orderRevision: snapshot.orderRevision,
+      incrementVersion: false
+    });
+    const context = this.getAvailabilityContextEntry(contextId);
+    const handle = this.createAvailabilityContextRef(context);
+    const payload = {
+      context: handle,
+      contextVersion: context.activeVersion,
+      projection: projectionEntry.projection,
+      refreshed: false,
+      reason: 'prepare'
+    };
+    await this.emitAvailabilityDiagnostic({
+      action: 'prepare',
+      contextId,
+      contextVersion: context.activeVersion,
+      projection: projectionEntry.projection,
+      snapshotId: context.lastSnapshotId,
+      orderRevision: context.lastKnownOrderRevision,
+      reason: 'prepare'
+    });
+    await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onAvailabilityProjectionPrepared}`, payload);
+    return handle;
   }
 
-  /** Stores a UI choice only. It is deliberately side-effect free with respect to tempOrder. */
-  setPlannerSelection(patch) {
-    return this.getPlanner().setSelectionPatch(patch);
+  /** Candidate calculation over the current context projection and runtime minute. */
+  async getProductTimeRanges(contextId, request = {}) {
+    const {
+      context,
+      projectionEntry
+    } = await this.ensureAvailabilityContextProjection(contextId, 'get_product_time_ranges');
+    const contextVersion = context.activeVersion;
+    const allowOutsideOperatingHoursForRequestedStartTimes = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos' && Object.values(request.durationStartTimesByProductId || {}).some(startTimes => Array.isArray(startTimes) && startTimes.length > 0);
+    return (0, _ResourcePlanner.getProductTimeRanges)(projectionEntry.projection, {
+      ...request,
+      ...(allowOutsideOperatingHoursForRequestedStartTimes ? {
+        allowOutsideOperatingHoursForRequestedStartTimes: true
+      } : {})
+    }, {
+      evaluatedAt: this.getAvailabilityRuntimeDateTime()
+    }).map(group => ({
+      ...group,
+      ranges: group.ranges.map(candidate => this.decorateAvailabilityCandidate(context.contextId, contextVersion, candidate))
+    }));
   }
 
-  /**
-   * Legacy-friendly automatic assignment for already fixed intervals. Duration products without a
-   * start time intentionally remain unresolved; callers offering a picker should use slots.
-   */
-  async autoAssignPlanner(query = {}) {
-    const result = this.getPlanner().autoAssign(query);
-    if (result.conflicts.length) {
-      console.warn('[UnifiedBookingSales] autoAssignPlanner 存在未分配项', result.conflicts);
+  /** Thin facade: auto-refresh on cart drift, then delegate to the pure projection query. */
+  async queryBookingAvailability(contextId, request) {
+    const {
+      context,
+      projectionEntry,
+      refreshed
+    } = await this.ensureAvailabilityContextProjection(contextId, 'query_booking_availability');
+    this.assertContextualQueryFreshness(context, request);
+    const result = (0, _ResourcePlanner.queryAvailabilityProjection)(projectionEntry.projection, request);
+    const contextVersion = context.activeVersion;
+    const contextualResult = result.target === 'time' ? {
+      ...result,
+      data: result.data.map(group => ({
+        ...group,
+        times: group.times.map(item => ({
+          ...item,
+          availabilityContextId: context.contextId,
+          availabilityContextVersion: contextVersion
+        }))
+      }))
+    } : result.target === 'resource' ? {
+      ...result,
+      data: result.data.map(group => ({
+        ...group,
+        ranges: group.ranges.map(rangeGroup => ({
+          ...rangeGroup,
+          range: {
+            ...rangeGroup.range,
+            availabilityContextId: context.contextId,
+            availabilityContextVersion: contextVersion
+          }
+        }))
+      }))
+    } : result;
+    return {
+      ...contextualResult,
+      contextId: context.contextId,
+      contextVersion,
+      refreshed
+    };
+  }
+  releaseAvailabilityContext(contextId) {
+    const context = this.availabilityContextRegistry.get(contextId);
+    if (!context) return;
+    this.removeAvailabilityContext(contextId);
+    void this.emitAvailabilityDiagnostic({
+      action: 'release',
+      contextId,
+      contextVersion: context.activeVersion,
+      projection: this.getActiveAvailabilityProjectionEntry(context)?.projection || null,
+      snapshotId: context.lastSnapshotId,
+      orderRevision: context.lastKnownOrderRevision,
+      reason: 'explicit_release'
+    });
+  }
+  assertAvailabilityCommitWriteCAS(params) {
+    const context = this.availabilityContextRegistry.get(params.contextId);
+    if (!context) {
+      throw this.createAvailabilityFacadeError('AVAILABILITY_CONTEXT_NOT_FOUND', 'availability context 不存在或已失效，请重新 prepare', {
+        contextId: params.contextId
+      });
     }
-    return this.getPlanner().getSnapshot();
+    if (this.availabilityLifecycleGeneration !== params.expectedLifecycleGeneration || context.lifecycleGeneration !== params.expectedLifecycleGeneration || context.activeVersion !== params.expectedVersion || context.refreshNonce !== params.expectedRefreshNonce || this.getCurrentOrderRevision() !== params.expectedOrderRevision) {
+      throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', 'availability context 已变化，当前选择已失效，请重新获取候选', {
+        contextId: params.contextId,
+        expectedVersion: params.expectedVersion,
+        currentVersion: context.activeVersion,
+        expectedRefreshNonce: params.expectedRefreshNonce,
+        currentRefreshNonce: context.refreshNonce,
+        expectedLifecycleGeneration: params.expectedLifecycleGeneration,
+        currentLifecycleGeneration: this.availabilityLifecycleGeneration,
+        expectedOrderRevision: params.expectedOrderRevision,
+        currentOrderRevision: this.getCurrentOrderRevision()
+      });
+    }
+    return context;
   }
-
-  /** Rechecks remote events, capacity and conflicts among the current selection before committing. */
-  validatePlannerSelection() {
-    return this.getPlanner().validateSelection();
+  findProductLineByUid(productLineUid) {
+    return (this.getTempOrder()?.products || []).find(product => getProductLineUid(product) === String(productLineUid));
   }
-
-  /** Read-only snapshot for UI diagnostics and progressive flow steps. */
-  getPlannerSnapshot() {
-    return this.getPlanner().getSnapshot();
+  findLinkedBooking(product) {
+    const productUid = getProductLineUid(product);
+    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);
   }
 
-  /**
-   * Validates then writes assignments to tempOrder. Real order submission is opt-in so UI callers
-   * can safely preview the cart; pass submitAfterCommit only after an explicit confirmation.
-   */
-  async commitPlannerSelection(params = {}) {
-    if (params.selection) {
-      this.setPlannerSelection(params.selection);
-    }
-    if (params.assignments) {
-      this.setPlannerSelection({
-        assignments: params.assignments
+  /** Revalidates against the latest landed occupancy cache, then mutates exactly one product line. */
+  async commitAvailabilitySelection(contextId, params) {
+    const normalizedContextId = String(contextId || '').trim();
+    if (!normalizedContextId) {
+      throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'commitAvailabilitySelection 缺少 contextId', {
+        candidate: params.candidate
       });
     }
-    const snapshot = this.getPlannerSnapshot();
-    const assignments = snapshot.selection.assignments || [];
-    if (assignments.length === 0) {
-      return {
-        tempOrder: this.getTempOrder(),
-        assignments,
-        validation: {
-          ok: false,
-          conflicts: [{
-            type: 'missing_assignment',
-            message: '没有可提交的 planner assignment，请先执行 autoAssignPlanner 或传入 assignments'
-          }]
+    await this.tryAcquireAvailabilityCommitLock(normalizedContextId);
+    try {
+      const bookingCount = Number(params.bookingCount ?? 1);
+      if (!Number.isInteger(bookingCount) || bookingCount <= 0) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_RESERVATION_QUANTITY', 'bookingCount 必须是正整数', {
+          bookingCount: params.bookingCount
+        });
+      }
+      if (params.mode === 'edit' && bookingCount !== 1) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_RESERVATION_QUANTITY', '编辑预约商品时 bookingCount 必须为 1', {
+          bookingCount
+        });
+      }
+      const orderProductQuantity = params.orderProduct?.num ?? params.orderProduct?.quantity ?? params.orderProduct?._extend?.quantity;
+      if (orderProductQuantity !== undefined && orderProductQuantity !== null && Number(orderProductQuantity) !== bookingCount) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_RESERVATION_QUANTITY', 'orderProduct 数量与 bookingCount 不一致', {
+          bookingCount,
+          orderProductQuantity
+        });
+      }
+      const partySize = Number(params.partySize);
+      if (!Number.isInteger(partySize) || partySize <= 0) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_RESERVATION_QUANTITY', 'partySize 必须是正整数', {
+          partySize: params.partySize
+        });
+      }
+      const {
+        context,
+        projectionEntry,
+        refreshed
+      } = await this.ensureAvailabilityContextProjection(normalizedContextId, 'commit_precheck');
+      if (refreshed) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', 'availability context 已刷新，请重新获取候选', {
+          contextId: normalizedContextId,
+          currentContextVersion: context.activeVersion,
+          candidateContextVersion: params.candidate.availabilityContextVersion
+        });
+      }
+      const boundEditingUids = context.prepareParams.editingProductLineUids || [];
+      if (params.mode === 'edit') {
+        if (!params.productLineUid || !boundEditingUids.includes(String(params.productLineUid))) {
+          throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', 'edit context 与当前商品行不匹配，请重新 prepare 编辑上下文', {
+            contextId: normalizedContextId,
+            productLineUid: params.productLineUid,
+            editingProductLineUids: boundEditingUids
+          });
         }
+      } else if (boundEditingUids.length > 0) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', 'edit context 不能用于 add，请重新 prepare 新增上下文', {
+          contextId: normalizedContextId,
+          editingProductLineUids: boundEditingUids
+        });
+      }
+      if (projectionEntry.contextVersion !== context.activeVersion) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', 'availability context 已刷新，请重新获取候选', {
+          contextId: normalizedContextId,
+          currentContextVersion: context.activeVersion,
+          projectionContextVersion: projectionEntry.contextVersion
+        });
+      }
+      if (projectionEntry.orderRevision !== this.getCurrentOrderRevision()) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '购物车已变化，请重新获取候选', {
+          contextId: normalizedContextId,
+          currentContextVersion: context.activeVersion,
+          projectionOrderRevision: projectionEntry.orderRevision,
+          currentOrderRevision: this.getCurrentOrderRevision()
+        });
+      }
+      if (projectionEntry.contextVersion !== params.candidate.availabilityContextVersion) {
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '候选已过期，请重新获取最新时间段', {
+          contextId: normalizedContextId,
+          candidateContextVersion: params.candidate.availabilityContextVersion,
+          currentContextVersion: context.activeVersion
+        });
+      }
+      this.assertAvailabilityCandidateFreshness(context, params.candidate);
+      const orderProductId = params.orderProduct?.product_id ?? params.orderProduct?.id;
+      if (!sameAvailabilityId(orderProductId, params.candidate.productId)) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'orderProduct 与 candidate 商品不一致', {
+          orderProductId,
+          candidateProductId: params.candidate.productId
+        });
+      }
+      if (params.mode === 'edit' && !params.productLineUid) {
+        throw new _ResourcePlanner.AvailabilityError('PRODUCT_LINE_NOT_FOUND', 'edit 模式必须提供 productLineUid');
+      }
+      const editingLine = params.mode === 'edit' ? this.findProductLineByUid(String(params.productLineUid)) : undefined;
+      if (params.mode === 'edit' && !editingLine) {
+        throw new _ResourcePlanner.AvailabilityError('PRODUCT_LINE_NOT_FOUND', '找不到要编辑的预约商品行', {
+          productLineUid: params.productLineUid
+        });
+      }
+      if (editingLine && !sameAvailabilityId(editingLine.product_id ?? editingLine.id, params.candidate.productId)) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', '编辑商品行与 candidate 商品不一致', {
+          productLineUid: params.productLineUid,
+          productLineProductId: editingLine.product_id ?? editingLine.id,
+          candidateProductId: params.candidate.productId
+        });
+      }
+      if (!Array.isArray(params.requirementSelections)) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'requirementSelections 必须是数组', {
+          requirementSelections: params.requirementSelections
+        });
+      }
+      const baseProjection = projectionEntry.projection;
+      let commitWriteGuard = {
+        contextId: normalizedContextId,
+        expectedVersion: context.activeVersion,
+        expectedRefreshNonce: context.refreshNonce,
+        expectedLifecycleGeneration: this.availabilityLifecycleGeneration,
+        expectedOrderRevision: String(baseProjection.meta.orderRevision ?? '')
       };
-    }
-    const validation = this.validatePlannerSelection();
-    if (!validation.ok) {
-      return {
-        tempOrder: this.getTempOrder(),
-        assignments,
-        validation
+      const prepareParams = baseProjection.meta.prepareParams;
+      if (!prepareParams) {
+        throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', 'projection 缺少 prepareParams，无法执行缓存重校验');
+      }
+      const fallbackResources = {
+        resources: (0, _lodashEs.cloneDeep)([...(baseProjection.resources || [])]),
+        resourceOccupancies: (0, _lodashEs.cloneDeep)([...(baseProjection.resourceOccupancies || [])].filter(occupancy => occupancy.source !== 'cart')),
+        includesInjectedRawOccupancies: true
       };
-    }
-    const productsById = new Map(snapshot.context.products.map(product => [String(product.id), product]));
-    await this.removeExistingStagedLines('unified_booking_sales');
-    const assignmentGroups = new Map();
-    assignments.forEach(assignment => {
-      const key = buildAssignmentGroupKey(assignment);
-      assignmentGroups.set(key, [...(assignmentGroups.get(key) || []), assignment]);
-    });
-    for (const groupAssignments of assignmentGroups.values()) {
-      const product = productsById.get(String(groupAssignments[0].productId));
-      if (!product) continue;
-      const sourceProduct = product.raw || {
-        id: product.id,
-        title: product.title,
-        price: product.price
+      const commitSnapshot = await this.buildAvailabilityProjectionSnapshot({
+        ...this.cloneAvailabilityPrepareParams(prepareParams),
+        editingProductLineUids: params.mode === 'edit' && params.productLineUid ? [params.productLineUid] : []
+      }, {
+        resourceFetchPolicy: 'cache_only',
+        fallbackResources,
+        durationCandidateAnchorAt: this.getAvailabilityDurationCandidateAnchorAt(baseProjection) || context.durationCandidateAnchorAt
+      });
+      const refreshedProjection = commitSnapshot.projection;
+      if (String(refreshedProjection.meta.orderRevision ?? '') !== String(baseProjection.meta.orderRevision ?? '')) {
+        await this.refreshAvailabilityContextProjection({
+          contextId: normalizedContextId,
+          reason: 'commit_order_revision_changed',
+          previousOrderRevision: String(baseProjection.meta.orderRevision ?? '')
+        });
+        const latestContext = this.getAvailabilityContextEntry(normalizedContextId);
+        throw this.createAvailabilityFacadeError('AVAILABILITY_SELECTION_STALE', '最终缓存重校验期间购物车已变化，请重新获取候选', {
+          contextId: normalizedContextId,
+          candidateContextVersion: params.candidate.availabilityContextVersion,
+          currentContextVersion: latestContext.activeVersion,
+          projectionOrderRevision: baseProjection.meta.orderRevision,
+          refreshedOrderRevision: refreshedProjection.meta.orderRevision,
+          snapshotId: baseProjection.meta.snapshotId,
+          refreshedSnapshotId: refreshedProjection.meta.snapshotId
+        });
+      }
+      this.assertAvailabilityCommitWriteCAS(commitWriteGuard);
+      const candidateDurationMinutes = getCandidateDurationMinutes(params.candidate);
+      const candidateStartTime = getCandidateStartTime(params.candidate);
+      const allowPosAvailabilityOverride = String(this.otherParams?.platform ?? '').trim().toLowerCase() === 'pos';
+      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)
+        },
+        ...(candidateDurationMinutes ? {
+          durationMinutesByProductId: {
+            [String(params.candidate.productId)]: candidateDurationMinutes
+          },
+          ...(candidateStartTime ? {
+            durationStartTimesByProductId: {
+              [String(params.candidate.productId)]: [candidateStartTime]
+            },
+            ...(allowPosAvailabilityOverride ? {
+              allowOutsideOperatingHoursForRequestedStartTimes: true
+            } : {})
+          } : {})
+        } : {})
+      }).flatMap(group => group.ranges);
+      const refreshedCandidateBase = refreshedRanges.find(candidate => candidate.startAt === params.candidate.startAt && candidate.endAt === params.candidate.endAt && candidate.bookingStartAt === params.candidate.bookingStartAt && candidate.bookingEndAt === params.candidate.bookingEndAt);
+      if (!refreshedCandidateBase) {
+        throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '缓存重校验后候选时间已不在商品配置中', {
+          contextId: normalizedContextId,
+          candidate: params.candidate,
+          refreshedSnapshotId: refreshedProjection.meta.snapshotId
+        });
+      }
+      const product = refreshedProjection.products.find(item => sameAvailabilityId(item.id, refreshedCandidateBase.productId));
+      if (!product) {
+        throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', '缓存重校验后商品不在 projection 中', {
+          productId: refreshedCandidateBase.productId
+        });
+      }
+      let validation = (0, _ResourcePlanner.validateAvailabilitySelection)(refreshedProjection, {
+        candidate: refreshedCandidateBase,
+        requirementSelections: params.requirementSelections,
+        partySize,
+        bookingCount
+      });
+      if (allowPosAvailabilityOverride && !validation.ok && validation.conflicts.every(conflict => POS_OVERRIDABLE_AVAILABILITY_CONFLICT_CODES.has(conflict.code))) {
+        const forced = buildPosForcedAvailabilityAssignments({
+          product,
+          resources: refreshedProjection.resources,
+          candidate: refreshedCandidateBase,
+          requirementSelections: params.requirementSelections,
+          partySize
+        });
+        validation = forced.conflicts.length > 0 ? {
+          ...validation,
+          assignments: [],
+          conflicts: forced.conflicts
+        } : {
+          ...validation,
+          ok: true,
+          status: validation.availability.status,
+          assignments: forced.assignments,
+          conflicts: []
+        };
+      }
+      if (!validation.ok) {
+        const capacityConflict = validation.conflicts.find(conflict => conflict.code === 'resource_capacity_exceeded');
+        throw new _ResourcePlanner.AvailabilityError('REVALIDATION_FAILED', capacityConflict?.message || '缓存重校验后资源已不可提交', {
+          validation,
+          refreshedSnapshotId: refreshedProjection.meta.snapshotId
+        });
+      }
+      // Revalidation failure must leave the caller's candidate reusable. Only publish the
+      // refreshed projection/version after candidate and resource validation has passed;
+      // otherwise a second Confirm from the still-open modal would incorrectly become stale.
+      const revalidationEntry = this.storeAvailabilityProjectionEntry({
+        contextId: normalizedContextId,
+        prepareParams: commitSnapshot.prepareParams,
+        prepareKey: context.prepareKey,
+        projection: refreshedProjection,
+        orderRevision: commitSnapshot.orderRevision,
+        incrementVersion: true
+      });
+      const revalidatedContext = this.getAvailabilityContextEntry(normalizedContextId);
+      await this.emitAvailabilityDiagnostic({
+        action: 'refresh',
+        contextId: normalizedContextId,
+        contextVersion: revalidatedContext.activeVersion,
+        projection: refreshedProjection,
+        snapshotId: revalidationEntry.snapshotId,
+        orderRevision: revalidationEntry.orderRevision,
+        previousOrderRevision: baseProjection.meta.orderRevision,
+        reason: 'commit_cached_occupancy_revalidation'
+      });
+      commitWriteGuard = {
+        contextId: normalizedContextId,
+        expectedVersion: revalidatedContext.activeVersion,
+        expectedRefreshNonce: revalidatedContext.refreshNonce,
+        expectedLifecycleGeneration: this.availabilityLifecycleGeneration,
+        expectedOrderRevision: revalidationEntry.orderRevision
       };
-      const productInput = this.buildUnifiedOrderProduct(sourceProduct, 'unified_booking_sales', product);
-      if (!productInput) continue;
-      await this.addProductToOrder(productInput, buildBookingFromAssignments({
-        assignments: groupAssignments,
-        product
-      }));
-    }
-    let submitResult;
-    if (params.submitAfterCommit) {
-      submitResult = await this.submitSalesOrder();
+      const refreshedCandidate = this.decorateAvailabilityCandidate(normalizedContextId, revalidatedContext.activeVersion, refreshedCandidateBase);
+      const existingBooking = editingLine ? this.findLinkedBooking(editingLine) : undefined;
+      const existingBookingUid = existingBooking ? getBookingUid(existingBooking) : '';
+      if (params.mode === 'edit' && !existingBookingUid) {
+        throw new _ResourcePlanner.AvailabilityError('PRODUCT_LINE_NOT_FOUND', '编辑商品行缺少关联 booking', {
+          productLineUid: params.productLineUid
+        });
+      }
+      this.assertAvailabilityCommitWriteCAS(commitWriteGuard);
+      const booking = buildBookingFromAvailabilitySelection({
+        assignments: validation.assignments,
+        candidate: refreshedCandidate,
+        product,
+        resources: refreshedProjection.resources,
+        bookingUid: existingBookingUid || undefined,
+        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
+      });
+      const transformed = this.buildUnifiedOrderProduct({
+        ...params.orderProduct,
+        num: bookingCount,
+        quantity: bookingCount
+      }, 'unified_booking_sales', product);
+      if (!transformed) {
+        throw new _ResourcePlanner.AvailabilityError('INVALID_TARGET_FILTER', 'orderProduct 无法转换为订单行', {
+          orderProduct: params.orderProduct
+        });
+      }
+      transformed.num = bookingCount;
+      transformed.metadata = {
+        ...(transformed.metadata || {}),
+        unified_booking_sales: true,
+        availability_candidate_key: refreshedCandidate.key,
+        availability_context_id: normalizedContextId,
+        availability_context_version: refreshedCandidate.availabilityContextVersion
+      };
+      let productLineUid = '';
+      let bookingUid = '';
+      let productLineUids = [];
+      let bookingUids = [];
+      if (params.mode === 'edit' && editingLine && params.productLineUid) {
+        transformed.product_sku = transformed.product_sku ?? editingLine.product_sku;
+        transformed.product_bundle = transformed.product_bundle ?? editingLine.product_bundle;
+        transformed.booking_uid = existingBookingUid;
+        transformed.metadata = {
+          ...(editingLine.metadata || {}),
+          ...(transformed.metadata || {}),
+          unique_identification_number: params.productLineUid,
+          booking_uid: existingBookingUid
+        };
+        await this.updateOrderProduct({
+          product_id: transformed.product_id ?? editingLine.product_id,
+          product_variant_id: transformed.product_variant_id ?? editingLine.product_variant_id ?? 0,
+          unique_identification_number: params.productLineUid,
+          updates: transformed,
+          booking,
+          ...(params.allowBookingReprice !== undefined ? {
+            allow_booking_reprice: params.allowBookingReprice
+          } : {}),
+          ...(params.allowBookingDiscountReapply !== undefined ? {
+            allow_booking_discount_reapply: params.allowBookingDiscountReapply
+          } : {})
+        });
+        productLineUid = params.productLineUid;
+        bookingUid = existingBookingUid;
+        productLineUids = [productLineUid];
+        bookingUids = [bookingUid];
+      } 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
+        } : undefined);
+        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)));
+        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);
+        }
+        productLineUid = productLineUids[productLineUids.length - 1] || '';
+        bookingUid = bookingUids[bookingUids.length - 1] || '';
+      }
+      this.invalidateAvailabilityContextsAfterCommit();
+      const nextContext = this.getAvailabilityContextEntry(normalizedContextId);
+      const result = {
+        contextId: normalizedContextId,
+        contextVersion: nextContext.activeVersion,
+        tempOrder: this.getTempOrder(),
+        validation,
+        candidate: refreshedCandidate,
+        productLineUid,
+        bookingUid,
+        productLineUids,
+        bookingUids
+      };
+      await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onAvailabilitySelectionCommitted}`, result);
+      return result;
+    } finally {
+      await this.releaseAvailabilityCommitLock(normalizedContextId);
     }
-    const result = {
-      tempOrder: this.getTempOrder(),
-      assignments,
-      validation,
-      submitResult
-    };
-    await this.core.effects.emit(`${this.name}:${_types.UnifiedBookingSalesHooks.onPlannerCommitted}`, result);
-    return result;
   }
 }
 exports.UnifiedBookingSalesImpl = UnifiedBookingSalesImpl;