@pisell/pisellos 2.3.71 → 2.3.73

package/lib/solution/UnifiedBookingSales/index.js

@@ -30,25 +30,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/solution/UnifiedBookingSales/index.ts
 var UnifiedBookingSales_exports = {};
 __export(UnifiedBookingSales_exports, {
+  AvailabilityError: () => import_ResourcePlanner2.AvailabilityError,
   UnifiedBookingSales: () => UnifiedBookingSales,
   UnifiedBookingSalesImpl: () => UnifiedBookingSalesImpl,
-  buildBookingFromAssignment: () => buildBookingFromAssignment,
-  buildBookingFromAssignments: () => buildBookingFromAssignments,
+  buildAvailabilityLineIdentity: () => buildAvailabilityLineIdentity,
+  buildAvailabilityResourcesFromV2: () => buildAvailabilityResourcesFromV2,
+  buildBookingFromAvailabilityAssignment: () => buildBookingFromAvailabilityAssignment,
+  buildBookingFromAvailabilityAssignments: () => buildBookingFromAvailabilityAssignments,
   buildPlannerDiscountResult: () => buildPlannerDiscountResult,
-  buildPlannerLineIdentity: () => buildPlannerLineIdentity,
-  buildPlannerResourcesFromV2: () => buildPlannerResourcesFromV2,
-  collectPlannerResourceIds: () => collectPlannerResourceIds,
-  normalizeProductForPlanner: () => normalizeProductForPlanner
+  collectAvailabilityResourceIds: () => collectAvailabilityResourceIds,
+  normalizeProductForAvailability: () => normalizeProductForAvailability
 });
 module.exports = __toCommonJS(UnifiedBookingSales_exports);
 var import_dayjs = __toESM(require("dayjs"));
+var import_lodash_es = require("lodash-es");
 var import_modules = require("../../modules");
 var import_getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
+var import_ResourcePlanner = require("../../modules/ResourcePlanner");
 var import_types = require("./types");
+var import_remoteOccupancyCache = require("./remoteOccupancyCache");
 var import_BookingTicket = require("../BookingTicket");
+var import_localClock = require("../../modules/ResourcePlanner/localClock");
 __reExport(UnifiedBookingSales_exports, require("./types"), module.exports);
-var OPEN_DATA_SECTION_CODES = ["sale", "reservation", "fulfillment", "menu", "workflow"];
+var import_ResourcePlanner2 = require("../../modules/ResourcePlanner");
+var OPEN_DATA_SECTION_CODES = ["sale", "reservation", "fulfillment", "menu", "workflow", "basic", "checkout", "availability"];
 var OPEN_DATA_CACHE_TTL = 5 * 60 * 1e3;
+function normalizePositiveInteger(value) {
+  const normalized = Number(value);
+  if (!Number.isInteger(normalized) || normalized <= 0)
+    return void 0;
+  return normalized;
+}
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -166,88 +178,473 @@ function filterCustomerBoundDiscounts(discountList) {
     return [];
   return discountList.filter((discount) => !isCustomerBoundDiscount(discount));
 }
+var DEFAULT_AVAILABILITY_SLOT_STEP_MINUTES = 30;
+var DEFAULT_AVAILABILITY_BUSINESS_HOURS = {
+  startTime: "09:00",
+  endTime: "18:00"
+};
+var MAX_AVAILABILITY_RANGE_DAYS = 90;
+var MAX_AVAILABILITY_CONTEXT_REGISTRY = 128;
+var MAX_AVAILABILITY_PROJECTION_POOL = 16;
+var 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 import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", "timezone label 不能为空", {
+      timezone: timezoneName
+    });
+  }
+}
+function normalizeAvailabilityLocalDateTime(value, fixedOffsetMinutes) {
+  if (value == null || value === "")
+    return null;
+  try {
+    const localText = typeof (value == null ? void 0 : value.format) === "function" ? value.format("YYYY-MM-DDTHH:mm:ss") : String(value);
+    return (0, import_localClock.formatLocalDateTime)((0, import_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, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(startText));
+  let endScalar = (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(endText));
+  if (endScalar <= startScalar && params.rollOverEnd) {
+    endScalar = (0, import_localClock.addLocalCalendarDays)(endScalar, 1);
+  }
+  if (endScalar <= startScalar)
+    return null;
+  return {
+    startAt: startText,
+    endAt: (0, import_localClock.formatLocalDateTime)(endScalar, params.fixedOffsetMinutes),
+    startScalar,
+    endScalar
+  };
+}
+function sameAvailabilityId(left, right) {
+  return left !== void 0 && left !== null && right !== void 0 && right !== null && String(left) === String(right);
+}
+function uniqueAvailabilityIds(values) {
+  const result = /* @__PURE__ */ new Map();
+  values.forEach((value) => {
+    const id = toNumberId(value);
+    if (id !== void 0)
+      result.set(String(id), id);
+  });
+  return Array.from(result.values());
+}
+function assertAvailabilityCatalogProductIds(productIds, context) {
+  if (productIds == null)
+    return;
+  if (!Array.isArray(productIds)) {
+    throw new import_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 import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", `${context} 只能包含有限数值商品 ID`, {
+      context,
+      invalidIds,
+      productIds
+    });
+  }
+}
+function normalizeResourceType(_value) {
+  return "single";
+}
 function resolveProductKind(product) {
   var _a, _b, _c;
-  if (product.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 (((_a = product.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = product._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session))
+  if (((_a = product.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = product._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session) || product.session) {
     return "session";
-  if (Array.isArray(product["schedule.ids"]) && product["schedule.ids"].length > 0)
+  }
+  const scheduleIds = product["schedule.ids"] || product.schedule_ids;
+  if (Array.isArray(scheduleIds) && scheduleIds.length > 0)
     return "session";
   return "normal";
 }
-function normalizeSchedule(product) {
-  var _a, _b, _c;
-  const session = ((_a = product.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = product._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session) || product.session;
-  if ((session == null ? void 0 : session.start_at) && (session == null ? void 0 : 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 = /* @__PURE__ */ new Set();
+  values.forEach((value) => {
+    if (typeof value === "string") {
+      try {
+        dates.add((0, import_localClock.formatLocalDate)((0, import_localClock.parseLocalDate)(value.slice(0, 10))));
+      } catch {
+      }
+      return;
+    }
+    const startValue = (value == null ? void 0 : value.start) || (value == null ? void 0 : value.start_date) || (value == null ? void 0 : value.date);
+    const endValue = (value == null ? void 0 : value.end) || (value == null ? void 0 : value.end_date) || startValue;
+    let start;
+    let end;
+    try {
+      start = (0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(String(startValue).slice(0, 10)));
+      end = (0, import_localClock.localDateToScalarStart)((0, import_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, import_localClock.formatLocalDate)(cursor));
+      cursor = (0, import_localClock.addLocalCalendarDays)(cursor, 1);
+      guard += 1;
+    }
+  });
+  return Array.from(dates).sort();
 }
-function normalizeRequirements(product) {
+function normalizeRequirementGroups(product) {
   var _a;
   const resources = (_a = product.product_resource) == null ? void 0 : _a.resources;
   if (!Array.isArray(resources))
     return [];
-  return resources.filter((resource) => (resource == null ? void 0 : resource.status) !== 0).map((resource) => {
-    var _a2, _b;
+  return resources.filter((resource) => (resource == null ? void 0 : resource.status) !== 0).map((resource, index) => {
+    var _a2, _b, _c;
+    const formId = toNumberId(resource.id ?? resource.form_id);
+    const required = resource.required ?? resource.status === 1;
+    const resourceType = normalizeResourceType(resource.type);
+    const combinedIds = ((_a2 = resource.combined_resource) == null ? void 0 : _a2.status) === 1 ? (_b = resource.combined_resource) == null ? void 0 : _b.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 {
-      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 !== void 0),
-      resourceType: resource.type || ((_a2 = resource.select_type) == null ? void 0 : _a2.type) || "single",
-      required: resource.status === 1,
-      capacityRequired: Number(((_b = product.capacity) == null ? void 0 : _b.default) || product.capacity || 1) || 1
+      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 ?? ((_c = product.capacity) == null ? void 0 : _c.default) ?? product.capacity ?? 1
+      ) || 1),
+      raw: resource
     };
   });
 }
-function normalizeProductForPlanner(product) {
+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, import_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) {
   var _a, _b;
+  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) : void 0;
+  const configuredEndDate = ((_a = repeatRule.end) == null ? void 0 : _a.type) === "date" ? (_b = repeatRule.end) == null ? void 0 : _b.end_date : void 0;
+  const endDate = configuredEndDate ? String(configuredEndDate).slice(0, 10) : void 0;
+  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) : void 0,
+      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, import_localClock.formatLocalTime)(String(startAt), false),
+          endTime: (0, import_localClock.formatLocalTime)(String(endAt), false)
+        });
+      } catch {
+      }
+    }
+  }
+  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 = /* @__PURE__ */ 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());
+}
+function normalizeProductForAvailability(product, scheduleList = [], fixedOffsetMinutes = (0, import_localClock.captureRuntimeOffsetMinutes)()) {
+  var _a, _b, _c, _d, _e;
   const raw = product;
   const kind = resolveProductKind(raw);
+  const sessionRules = [];
+  const sessionRanges = [];
+  const explicitSession = ((_a = raw.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = raw._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session) || raw.session;
+  const explicitRange = normalizeAbsoluteSessionRange({
+    startAt: explicitSession == null ? void 0 : explicitSession.start_at,
+    endAt: explicitSession == null ? void 0 : explicitSession.end_at,
+    scheduleId: toNumberId(explicitSession == null ? void 0 : explicitSession.schedule_id),
+    timeSlotId: toNumberId(explicitSession == null ? void 0 : 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(((_a = raw.duration) == null ? void 0 : _a.value) || raw.duration || raw.service_duration || 30) || 30,
-    schedule: normalizeSchedule(raw),
-    resourceRequirements: normalizeRequirements(raw),
-    capacityRequired: Number(((_b = raw.capacity) == null ? void 0 : _b.default) || raw.capacity || 1) || 1,
-    quantity: Number(raw.num || raw.quantity || 1) || 1,
-    price: raw.price ?? raw.selling_price ?? raw.base_price,
+    durationMinutes: kind === "duration" ? Math.max(1, Number(((_d = raw.duration) == null ? void 0 : _d.value) || raw.duration || raw.service_duration || 30) || 30) : void 0,
+    requirementGroups: normalizeRequirementGroups(raw),
+    sessionRules,
+    sessionRanges,
+    capacityRequired: Math.max(1, Number(((_e = raw.capacity) == null ? void 0 : _e.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 normalizeResource(raw) {
-  var _a, _b;
+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 void 0;
+  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 === void 0 ? {} : { 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 === void 0 ? {} : { futureDay: futureDay.futureDay }
+      };
+    }
+    return invalidAvailabilityCutOffPolicy(`未知的 cut_off_time.ongoing.type: ${ongoingType}`);
+  }
+  if (type === "before_start") {
+    return {
+      type: "before_start",
+      ...futureDay.futureDay === void 0 ? {} : { 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,
+      ...futureDay.futureDay === void 0 ? {} : { futureDay: futureDay.futureDay }
+    };
+  }
+  return invalidAvailabilityCutOffPolicy(`未知的 cut_off_time.type: ${type}`);
+}
+function normalizeResource(raw, fixedOffsetMinutes = (0, import_localClock.captureRuntimeOffsetMinutes)()) {
   const id = raw.resourceId ?? raw.resource_id ?? raw.id;
   if (id === void 0 || id === null || id === "")
     return null;
-  const combinedResourceIds = (_a = raw.combined_resource) == null ? void 0 : _a.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 || ((_b = raw.select_type) == null ? void 0 : _b.type)),
-    capacity: Number(raw.capacity || raw.max_capacity || 1) || 1,
-    times: Array.isArray(raw.times) ? raw.times : [],
-    childResourceIds: Array.isArray(combinedResourceIds) ? combinedResourceIds : void 0,
+    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
   };
 }
@@ -255,97 +652,81 @@ 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 !== void 0);
 }
-function collectRawScheduleIds(rawResources) {
-  const ids = /* @__PURE__ */ 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 == null ? void 0 : dateRange.start) || !(dateRange == null ? void 0 : dateRange.end))
+  if (!(dateRange == null ? void 0 : dateRange.startDate) || !(dateRange == null ? void 0 : dateRange.endDate))
     return [];
   const dates = [];
-  let cursor = (0, import_dayjs.default)(dateRange.start);
-  const end = (0, import_dayjs.default)(dateRange.end);
-  if (!cursor.isValid() || !end.isValid() || end.isBefore(cursor, "day"))
+  const startScalar = (0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(dateRange.startDate));
+  const endScalar = (0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(dateRange.endDate));
+  if (endScalar < startScalar)
     return dates;
-  while (cursor.isSame(end, "day") || cursor.isBefore(end, "day")) {
-    dates.push(cursor.format("YYYY-MM-DD"));
-    cursor = cursor.add(1, "day");
+  for (let cursor = startScalar; cursor <= endScalar; cursor = (0, import_localClock.addLocalCalendarDays)(cursor, 1)) {
+    dates.push((0, import_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)
+function normalizeResourceOccupancy(rawEvent, resourceId, source = "remote", fixedOffsetMinutes = (0, import_localClock.captureRuntimeOffsetMinutes)()) {
+  var _a, _b;
+  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;
-  const rawSource = rawEvent.source;
-  const source = rawSource === "remote" || rawSource === "cart" || rawSource === "selection" ? rawSource : "remote";
   return {
-    ...rawEvent,
+    id: rawEvent.id == null ? void 0 : 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 ?? ((_a = rawEvent.metadata) == null ? void 0 : _a.unique_identification_number),
+    productUid: rawEvent.product_uid ?? rawEvent.productUid ?? ((_b = rawEvent.metadata) == null ? void 0 : _b.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, import_dayjs.default)(rawStart);
-  const endBoundary = (0, import_dayjs.default)(rawEnd);
-  if (!startBoundary.isValid() || !endBoundary.isValid() || !endBoundary.isAfter(startBoundary)) {
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, import_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, import_dayjs.default)(`${date} 00:00:00`);
-    const dayEnd = (0, import_dayjs.default)(`${date} 23:59:59`);
-    const start = startBoundary.isAfter(dayStart) ? startBoundary : dayStart;
-    const end = endBoundary.isBefore(dayEnd) ? endBoundary : dayEnd;
-    if (!end.isAfter(start))
+    const dayStart = (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(`${date}T00:00:00`));
+    const dayEnd = (0, import_localClock.localDateTimeToScalar)((0, import_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, import_localClock.formatLocalDateTime)(start, fixedOffsetMinutes),
+      end_at: (0, import_localClock.formatLocalDateTime)(end, fixedOffsetMinutes),
       schedule_ids: scheduleIds,
       source: "resource_window_fallback"
     }];
   });
 }
-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, import_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)));
@@ -353,35 +734,53 @@ function buildPlannerResourcesFromV2(params) {
     if (missingScheduleIds.length > 0) {
       resource.raw = {
         ...resource.raw || raw,
-        _plannerMissingScheduleIds: missingScheduleIds
+        _availabilityMissingScheduleIds: missingScheduleIds
       };
     }
-    resource.times = dates.flatMap((date) => (0, import_getDateIsInSchedule.getScheduleStartEndTimePoints)(date, schedules).map((slot) => ({
-      start_at: (0, import_dayjs.default)(slot.start_at).format("YYYY-MM-DD HH:mm:ss"),
-      end_at: (0, import_dayjs.default)(slot.end_at).format("YYYY-MM-DD HH:mm:ss"),
-      schedule_ids: scheduleIds
+    const materializedWindows = dates.flatMap((date) => schedules.flatMap((schedule) => (0, import_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
   };
 }
-function collectPlannerResourceIds(products, explicitResourceIds = []) {
+function collectAvailabilityResourceIds(products, explicitResourceIds = []) {
   const ids = /* @__PURE__ */ new Map();
   const add = (value) => {
     if (value === void 0 || value === null || value === "")
@@ -391,76 +790,199 @@ function collectPlannerResourceIds(products, explicitResourceIds = []) {
   explicitResourceIds.forEach(add);
   products.forEach((product) => {
     var _a;
-    (_a = product.resourceRequirements) == null ? void 0 : _a.forEach((requirement) => {
+    (_a = product.requirementGroups) == null ? void 0 : _a.forEach((requirement) => {
       var _a2;
       (_a2 = requirement.resourceIds) == null ? void 0 : _a2.forEach(add);
     });
   });
   return Array.from(ids.values());
 }
-function samePlannerId(left, right) {
-  if (left === void 0 || right === void 0)
-    return false;
-  return String(left) === String(right);
+function getProductLineUid(product) {
+  var _a;
+  return String(
+    ((_a = product == null ? void 0 : product.metadata) == null ? void 0 : _a.unique_identification_number) ?? (product == null ? void 0 : 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] : void 0) || 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
+  };
 }
-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) => {
+      var _a;
+      return (_a = group.resourceIds) == null ? void 0 : _a.some((id) => sameAvailabilityId(id, resourceId));
+    });
+    return {
+      productId: assignment.productId ?? assignment.product_id,
+      resourceId,
+      formId: assignment.formId ?? assignment.form_id ?? (matchedGroup == null ? void 0 : matchedGroup.formId),
+      startAt: assignment.startAt ?? assignment.start_at,
+      endAt: assignment.endAt ?? assignment.end_at,
+      capacityRequired: assignment.capacityRequired ?? assignment.capacity_required ?? (matchedGroup == null ? void 0 : matchedGroup.capacityRequired),
+      scheduleId: assignment.scheduleId ?? assignment.schedule_id,
+      timeSlotId: assignment.timeSlotId ?? assignment.time_slot_id
+    };
+  });
+  const first = normalizedAssignments[0];
+  const fixedOffsetMinutes = params.fixedOffsetMinutes ?? (0, import_localClock.captureRuntimeOffsetMinutes)();
+  const range = normalizeAvailabilityLocalDateTimeRange({
+    startAt: first.startAt,
+    endAt: first.endAt,
+    fixedOffsetMinutes,
+    rollOverEnd: false
+  });
+  if (!range) {
+    throw new import_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, import_localClock.formatLocalTime)(range.startAt, false),
+    endTime: (0, import_localClock.formatLocalTime)(range.endAt, false),
+    timezone: String(params.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || "runtime"),
+    scheduleRefs: [],
+    primaryScheduleRef: void 0
+  };
+  return buildBookingFromAvailabilitySelection({
+    assignments: normalizedAssignments,
+    candidate,
     product: params.product
   });
 }
-function buildBookingFromAssignments(params) {
-  const { assignments, product } = params;
-  const firstAssignment = assignments[0];
-  const start = (0, import_dayjs.default)(firstAssignment.start_at);
-  const end = (0, import_dayjs.default)(firstAssignment.end_at);
+function getBookingUid(booking) {
+  var _a;
+  return String(
+    ((_a = booking == null ? void 0 : booking.metadata) == null ? void 0 : _a.unique_identification_number) ?? (booking == null ? void 0 : 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] !== void 0 && 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) => {
+    var _a;
+    return {
+      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 ?? ((_a = product.metadata) == null ? void 0 : _a.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) {
+  var _a, _b, _c, _d;
+  const {
+    assignments,
+    candidate,
+    product,
+    resources = [],
+    bookingUid
+  } = params;
+  const bookingStartAt = candidate.bookingStartAt || candidate.startAt;
+  const bookingEndAt = candidate.bookingEndAt || candidate.endAt;
+  const startScalar = (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(bookingStartAt));
+  const endScalar = (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(bookingEndAt));
+  const scheduleId = ((_a = candidate.primaryScheduleRef) == null ? void 0 : _a.scheduleId) ?? ((_b = assignments.find((assignment) => assignment.scheduleId != null)) == null ? void 0 : _b.scheduleId);
+  const timeSlotId = ((_c = candidate.primaryScheduleRef) == null ? void 0 : _c.timeSlotId) ?? ((_d = assignments.find((assignment) => assignment.timeSlotId != null)) == null ? void 0 : _d.timeSlotId);
+  if (product.kind === "session" && scheduleId == null) {
+    throw new import_ResourcePlanner.AvailabilityError("REVALIDATION_FAILED", "session 候选缺少真实 schedule identity", {
+      productId: product.id,
+      candidateKey: candidate.key,
+      scheduleRefs: candidate.scheduleRefs
+    });
+  }
   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 * 1e3))),
     like_status: "common",
-    schedule_id: 0,
+    schedule_id: scheduleId ?? 0,
     resources: assignments.map((assignment) => {
-      const requirement = findRequirementForAssignment(product, assignment);
+      const matchedResource = resources.find((resource) => sameAvailabilityId(resource.id, assignment.resourceId));
+      const resourceName = String((matchedResource == null ? void 0 : matchedResource.name) || "").trim();
       return {
         id: assignment.resourceId,
         resource_id: assignment.resourceId,
-        form_id: requirement == null ? void 0 : 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
     }
   };
 }
-function buildAssignmentGroupKey(assignment) {
-  return [
-    assignment.productId,
-    assignment.start_at,
-    assignment.end_at
-  ].join(":");
-}
-function buildPlannerLineIdentity(product) {
-  var _a;
-  return {
-    product_id: product.product_id,
-    product_variant_id: product.product_variant_id ?? 0,
-    unique_identification_number: ((_a = product.metadata) == null ? void 0 : _a.unique_identification_number) || product.unique_identification_number,
-    product_sku: product.product_sku,
-    product_bundle: product.product_bundle
-  };
-}
 var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
   constructor() {
     super(...arguments);
@@ -471,12 +993,334 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
     this.openDataTarget = null;
     this.loadOpenDataInFlight = null;
     this.loadOpenDataInFlightTarget = null;
+    this.availabilityRuntimeOffsetMinutes = null;
+    this.availabilityScheduleCatalog = null;
+    this.availabilityProjectionSequence = 0;
+    this.availabilityContextSequence = 0;
+    this.availabilityLifecycleGeneration = 0;
+    this.availabilityContextRegistry = /* @__PURE__ */ new Map();
+    this.availabilityProjectionPool = /* @__PURE__ */ new Map();
+    this.availabilityPrepareInFlight = /* @__PURE__ */ new Map();
+    this.availabilityProjectionRefreshInFlight = /* @__PURE__ */ new Map();
+    this.availabilityRemoteOccupancyCache = new import_remoteOccupancyCache.AvailabilityRemoteOccupancyCache(
+      MAX_REMOTE_OCCUPANCY_RESOURCE_DATE_CELLS
+    );
+    this.availabilityRemoteResourceQueryInFlight = /* @__PURE__ */ new Map();
+    this.availabilityRemoteResourceQuerySequence = 0;
+    this.availabilityRemoteResourceEpoch = 0;
+    this.availabilityCommitLocks = /* @__PURE__ */ new Set();
+  }
+  async initialize(core, options = {}) {
+    var _a, _b, _c, _d;
+    this.availabilityScheduleCatalog = null;
+    this.openDataTarget = null;
+    this.availabilityRuntimeOffsetMinutes = (0, import_localClock.captureRuntimeOffsetMinutes)();
+    this.clearAvailabilityRemoteResourceState();
+    await super.initialize(core, options);
+    const openDataBusinessCode = String(
+      ((_a = this.otherParams) == null ? void 0 : _a.businessCode) ?? ((_b = this.otherParams) == null ? void 0 : _b.business_code) ?? ""
+    ).trim();
+    const openDataChannel = String(((_c = this.otherParams) == null ? void 0 : _c.channel) ?? "").trim();
+    if (((_d = this.otherParams) == null ? void 0 : _d.openData) && openDataBusinessCode && openDataChannel) {
+      this.openDataTarget = `${openDataBusinessCode}+${openDataChannel}`;
+    }
+    this.captureAvailabilityScheduleCatalog();
   }
   getSubmitOrderSalesChannel() {
     var _a;
     const channel = String(((_a = this.otherParams) == null ? void 0 : _a.channel) ?? "").trim();
     return channel || super.getSubmitOrderSalesChannel();
   }
+  createAvailabilityFacadeError(code, message, details) {
+    return new import_ResourcePlanner.AvailabilityError(code, message, details);
+  }
+  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 ?? "")
+    };
+  }
+  normalizeAvailabilityIdList(values) {
+    if (!Array.isArray(values) || values.length === 0)
+      return void 0;
+    const uniqueMap = /* @__PURE__ */ new Map();
+    values.forEach((value) => {
+      uniqueMap.set(String(value), value);
+    });
+    return Array.from(uniqueMap.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([, value]) => value);
+  }
+  normalizeAvailabilityStringList(values) {
+    if (!Array.isArray(values) || values.length === 0)
+      return void 0;
+    return Array.from(new Set(values.map(String))).sort((left, right) => left.localeCompare(right));
+  }
+  normalizeAvailabilityPrepareDescriptor(params) {
+    var _a;
+    this.assertAvailabilityPrepareParams(params);
+    const timezone = String(
+      params.timezone || ((_a = this.otherParams) == null ? void 0 : _a.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 import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", "businessHours 必须使用 HH:mm", {
+        businessHours
+      });
+    }
+    return this.cloneAvailabilityPrepareParams({
+      ...params,
+      productIds: this.normalizeAvailabilityIdList(params.productIds),
+      resourceIds: this.normalizeAvailabilityIdList(params.resourceIds),
+      editingProductLineUids: this.normalizeAvailabilityStringList(params.editingProductLineUids),
+      dateRange,
+      timezone,
+      slotStepMinutes,
+      businessHours: { ...businessHours },
+      _availabilityOperatingHours: params._availabilityOperatingHours ? {
+        source: params._availabilityOperatingHours.source,
+        scheduleIds: [...params._availabilityOperatingHours.scheduleIds]
+      } : void 0,
+      mode
+    });
+  }
+  async resolveAvailabilityPrepareDefaults(params) {
+    var _a, _b, _c, _d;
+    const needsOperatingHours = params.businessHours === void 0;
+    const needsTimeSlice = params.slotStepMinutes === void 0;
+    if (!needsOperatingHours && !needsTimeSlice) {
+      return {
+        ...params,
+        _availabilityOperatingHours: {
+          source: "prepare_business_hours",
+          scheduleIds: []
+        }
+      };
+    }
+    const businessCode = String(
+      ((_a = this.otherParams) == null ? void 0 : _a.businessCode) ?? ((_b = this.otherParams) == null ? void 0 : _b.business_code) ?? ""
+    ).trim();
+    const channel = String(((_c = this.otherParams) == null ? void 0 : _c.channel) ?? "").trim();
+    const currentTarget = businessCode && channel ? `${businessCode}+${channel}` : null;
+    let openData = !currentTarget || this.openDataTarget === currentTarget ? (_d = this.otherParams) == null ? void 0 : _d.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 == null ? void 0 : openData["availability.operating_hours"]) ? openData == null ? void 0 : openData["availability.operating_hours"] : void 0
+    ) || [];
+    const configuredTimeSlice = needsTimeSlice ? normalizePositiveInteger(openData == null ? void 0 : openData["reservation.time_slice"]) : void 0;
+    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 } = {}) {
+    var _a;
+    const previousScope = this.getAvailabilityScopeDescriptor(this.otherParams || {});
+    const explicitlySetsOpenData = Object.prototype.hasOwnProperty.call(params, "openData");
+    await super.setOtherParams(params, { cover });
+    const nextScope = this.getAvailabilityScopeDescriptor(this.otherParams || {});
+    if (explicitlySetsOpenData) {
+      this.openDataTarget = ((_a = this.otherParams) == null ? void 0 : _a.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");
+    }
+  }
+  async destroy() {
+    this.availabilityScheduleCatalog = null;
+    this.availabilityRuntimeOffsetMinutes = null;
+    await this.resetAvailabilityProjectionState("destroy");
+    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, import_localClock.captureRuntimeOffsetMinutes)();
+    }
+    return this.availabilityRuntimeOffsetMinutes;
+  }
+  getAvailabilityRuntimeDateTime(value = /* @__PURE__ */ new Date()) {
+    return (0, import_localClock.formatLocalDateTime)((0, import_localClock.localDateToScalar)(value), this.getAvailabilityRuntimeOffsetMinutes());
+  }
+  cloneAvailabilityPrepareParams(params) {
+    var _a, _b;
+    return (0, import_lodash_es.cloneDeep)({
+      ...params,
+      productIds: params.productIds ? [...params.productIds] : void 0,
+      resourceIds: params.resourceIds ? [...params.resourceIds] : void 0,
+      rawProducts: params.rawProducts ? (0, import_lodash_es.cloneDeep)(params.rawProducts) : void 0,
+      rawResources: params.rawResources ? (0, import_lodash_es.cloneDeep)(params.rawResources) : void 0,
+      rawOccupancies: params.rawOccupancies ? (0, import_lodash_es.cloneDeep)(params.rawOccupancies) : void 0,
+      editingProductLineUids: params.editingProductLineUids ? [...params.editingProductLineUids] : void 0,
+      dateRange: params.dateRange ? { ...params.dateRange } : void 0,
+      businessHours: params.businessHours ? { ...params.businessHours } : void 0,
+      _availabilityOperatingHours: params._availabilityOperatingHours ? {
+        source: params._availabilityOperatingHours.source,
+        scheduleIds: [...params._availabilityOperatingHours.scheduleIds]
+      } : void 0,
+      catalogScope: ((_a = params.catalogScope) == null ? void 0 : _a.type) === "schedule" ? { ...params.catalogScope } : ((_b = params.catalogScope) == null ? void 0 : _b.type) === "productList" ? { type: "productList", params: { ...params.catalogScope.params } } : void 0
+    });
+  }
+  getAvailabilityDurationCandidateAnchorAt(projection) {
+    const value = projection == null ? void 0 : projection.meta.durationCandidateAnchorAt;
+    return typeof value === "string" && value.trim() ? value : void 0;
+  }
+  createAvailabilityContextRef(context) {
+    return {
+      contextId: context.contextId
+    };
+  }
+  async emitAvailabilityDiagnostic(payload) {
+    var _a, _b, _c;
+    await ((_c = (_b = (_a = this.core) == null ? void 0 : _a.effects) == null ? void 0 : _b.emit) == null ? void 0 : _c.call(
+      _b,
+      `${this.name}:${import_types.UnifiedBookingSalesHooks.onAvailabilityProjectionDiagnostic}`,
+      {
+        ...payload,
+        registrySize: this.availabilityContextRegistry.size,
+        projectionPoolSize: this.availabilityProjectionPool.size
+      }
+    ));
+  }
+  touchAvailabilityContext(context) {
+    context.lastAccessedAt = (/* @__PURE__ */ 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 == null ? void 0 : 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() {
     var _a;
     return Boolean(
@@ -545,12 +1389,9 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
     return 1;
   }
   getRegisteredModuleNames() {
-    return [...super.getRegisteredModuleNames(), "resourcePlanner", "openData"];
+    return [...super.getRegisteredModuleNames(), "openData"];
   }
   createSubModule(moduleName) {
-    if (moduleName === "resourcePlanner") {
-      return new import_modules.ResourcePlannerModule(`${this.name}_resourcePlanner`);
-    }
     if (moduleName === "openData") {
       return new import_modules.OpenDataModule(`${this.name}_openData`);
     }
@@ -896,22 +1737,16 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
       preferredDiscountFound: preferredDiscountId === void 0 || preferredDiscountId === null ? void 0 : 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 == null ? void 0 : product.raw) || {};
     const orderProduct = this.transformBaseProductToOrderProduct({
       payload: {
         ...sourceProduct,
         id: sourceProduct.id ?? (product == null ? void 0 : product.id),
         product_id: sourceProduct.product_id ?? sourceProduct.id ?? (product == null ? void 0 : product.id),
         quantity: sourceProduct.quantity ?? sourceProduct.num ?? (product == null ? void 0 : product.quantity) ?? 1,
-        price: sourceProduct.price ?? (product == null ? void 0 : product.price),
-        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? (product == null ? void 0 : product.price),
+        price: sourceProduct.price ?? normalizedProductRaw.price,
+        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? normalizedProductRaw.selling_price ?? normalizedProductRaw.price,
         metadata: {
           ...sourceProduct.metadata || {},
           [ownershipKey]: true
@@ -935,7 +1770,7 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
       return ((_a2 = product == null ? void 0 : product.metadata) == null ? void 0 : _a2[ownershipKey]) === true;
     });
     if (existingLines.length > 0) {
-      await this.removeProductsFromOrder(existingLines.map(buildPlannerLineIdentity));
+      await this.removeProductsFromOrder(existingLines.map(buildAvailabilityLineIdentity));
     }
   }
   async stageProducts(params, ownershipKey) {
@@ -966,15 +1801,8 @@ var UnifiedBookingSalesImpl = class extends import_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.
+   * Adds ordinary retail products without asking ResourcePlanner for booking facts.
+   * Its staged lines have separate ownership so planner and retail skins can coexist safely.
    */
   async stageRetailProducts(params) {
     return this.stageProducts(params, "unified_booking_sales_retail");
@@ -1021,57 +1849,200 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
     }
     return this.addProductToOrder(orderProduct);
   }
-  /** Normalizes caller-provided products or loads the catalog before any resource request is made. */
-  async loadPlannerProducts(params) {
-    var _a, _b, _c, _d, _e, _f;
-    if ((_b = (_a = params.context) == null ? void 0 : _a.products) == null ? void 0 : _b.length)
-      return params.context.products;
-    if ((_c = params.rawProducts) == null ? void 0 : _c.length)
-      return params.rawProducts.map(normalizeProductForPlanner);
-    const productIds = params.productIds || ((_d = params.productLoadParams) == null ? void 0 : _d.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) : (_e = params.productLoadParams) == null ? void 0 : _e.product_ids
+  normalizeAvailabilityDateRange(params, timezone) {
+    var _a, _b;
+    const today = (0, import_localClock.formatLocalDate)((0, import_localClock.localDateToScalar)(/* @__PURE__ */ new Date()));
+    const startDate = ((_a = params.dateRange) == null ? void 0 : _a.startDate) || today;
+    const endDate = ((_b = params.dateRange) == null ? void 0 : _b.endDate) || (0, import_localClock.formatLocalDate)((0, import_localClock.addLocalCalendarDays)((0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(startDate)), 31));
+    let startScalar;
+    let endScalar;
+    try {
+      startScalar = (0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(startDate));
+      endScalar = (0, import_localClock.localDateToScalarStart)((0, import_localClock.parseLocalDate)(endDate));
+    } catch (error) {
+      throw new import_ResourcePlanner.AvailabilityError("INVALID_DATE_RANGE", "日期范围必须是有效的 YYYY-MM-DD 且结束日期不早于开始日期", {
+        dateRange: { startDate, endDate },
+        timezone,
+        cause: error instanceof Error ? error.message : String(error)
       });
     }
-    return (((_f = this.getProductCatalog) == null ? void 0 : _f.call(this).products) || []).map(normalizeProductForPlanner);
+    if (endScalar < startScalar) {
+      throw new import_ResourcePlanner.AvailabilityError("INVALID_DATE_RANGE", "日期范围必须是有效的 YYYY-MM-DD 且结束日期不早于开始日期", {
+        dateRange: { startDate, endDate },
+        timezone
+      });
+    }
+    const inclusiveDays = Math.trunc((endScalar - startScalar) / (24 * 60 * 60 * 1e3)) + 1;
+    if (inclusiveDays > MAX_AVAILABILITY_RANGE_DAYS) {
+      throw new import_ResourcePlanner.AvailabilityError("RANGE_TOO_LARGE", "日期范围最多包含 90 个自然日", {
+        dateRange: { startDate, endDate },
+        inclusiveDays
+      });
+    }
+    return { startDate, endDate };
   }
-  /** Loads the reusable store-level schedule catalog on demand. */
-  async ensurePlannerSchedulesLoaded() {
-    var _a, _b, _c, _d, _e, _f;
-    if (!this.store.schedule)
-      throw new Error("[UnifiedBookingSales] schedule 模块未初始化");
-    const scheduleList = ((_b = (_a = this.store.schedule).getScheduleList) == null ? void 0 : _b.call(_a)) || [];
-    if (!((_d = (_c = this.store.schedule).isScheduleListLoaded) == null ? void 0 : _d.call(_c)) || scheduleList.length === 0) {
-      await this.store.schedule.loadAllSchedule();
+  assertAvailabilityPrepareParams(params) {
+    var _a, _b;
+    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(((_a = params.dateRange) == null ? void 0 : _a.startDate) || ((_b = params.dateRange) == null ? void 0 : _b.endDate));
+    if (!hasProductAnchor && !hasResourceAnchor && !hasDateAnchor) {
+      throw new import_ResourcePlanner.AvailabilityError("MISSING_ANCHOR", "prepare 至少需要 productIds、resourceIds 或 dateRange 之一", {
+        params
+      });
+    }
+    if (!hasProductAnchor && !params.catalogScope) {
+      throw new import_ResourcePlanner.AvailabilityError("MISSING_CATALOG_SCOPE", "缺少 productIds 时必须提供 catalogScope", {
+        params
+      });
+    }
+    if (params.slotStepMinutes !== void 0) {
+      const step = Number(params.slotStepMinutes);
+      if (!Number.isInteger(step) || step <= 0) {
+        throw new import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", "slotStepMinutes 必须是正整数", {
+          slotStepMinutes: params.slotStepMinutes
+        });
+      }
     }
-    return ((_f = (_e = this.store.schedule).getScheduleList) == null ? void 0 : _f.call(_e)) || [];
   }
-  /**
-   * 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) {
+  captureAvailabilityScheduleCatalog() {
     var _a, _b;
-    let scheduleList = await this.ensurePlannerSchedulesLoaded();
-    const scheduleIds = collectRawScheduleIds(rawResources);
-    if (!scheduleListHasIds(scheduleList, scheduleIds)) {
-      await this.store.schedule.loadAllSchedule({ useCache: false });
-      scheduleList = ((_b = (_a = this.store.schedule).getScheduleList) == null ? void 0 : _b.call(_a)) || [];
+    if (!this.store.schedule) {
+      throw new Error("[UnifiedBookingSales] schedule 模块未初始化");
+    }
+    this.availabilityScheduleCatalog = (0, import_lodash_es.cloneDeep)(
+      ((_b = (_a = this.store.schedule).getScheduleList) == null ? void 0 : _b.call(_a)) || []
+    );
+  }
+  /** Returns the solution-lifetime schedule snapshot captured after initialization. */
+  getAvailabilityScheduleCatalog() {
+    if (this.availabilityScheduleCatalog === null) {
+      throw new Error("[UnifiedBookingSales] schedule 快照未初始化");
     }
-    return scheduleList;
+    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 windows2 = 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: windows2
+      };
+    }
+    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, import_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) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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 (((_a = prepare.catalogScope) == null ? void 0 : _a.type) === "schedule") {
+      await this.loadScheduleAvailableDate({
+        startDate: dateRange.startDate,
+        endDate: dateRange.endDate,
+        custom_page_id: Number(prepare.catalogScope.customPageId) || void 0,
+        channel: prepare.catalogScope.channel
+      });
+      const dateSet = new Set(dateRangeDays(dateRange));
+      const scheduleProductIds = (((_c = (_b = this.store.schedule).getAvailabilityScheduleDateList) == null ? void 0 : _c.call(_b)) || []).filter((item) => dateSet.has(item.date)).flatMap((item) => item.product_ids || []);
+      const productIds = uniqueAvailabilityIds([
+        ...scheduleProductIds,
+        ...((_e = (_d = this.store.schedule).getOtherProductsIds) == null ? void 0 : _e.call(_d)) || []
+      ]);
+      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 (((_f = prepare.catalogScope) == null ? void 0 : _f.type) === "productList") {
+      rawProducts = await this.loadProducts({
+        ...prepare.catalogScope.params,
+        schedule_date: prepare.catalogScope.params.schedule_date || dateRange.startDate
+      });
+    }
+    const normalized = rawProducts.map((product) => normalizeProductForAvailability(
+      product,
+      params.scheduleList,
+      this.getAvailabilityRuntimeOffsetMinutes()
+    ));
+    if (!explicitProductIds.length && ((_g = prepare.resourceIds) == null ? void 0 : _g.length)) {
+      return normalized.filter((product) => {
+        var _a2;
+        return (_a2 = product.requirementGroups) == null ? void 0 : _a2.some((group) => {
+          var _a3;
+          return (_a3 = group.resourceIds) == null ? void 0 : _a3.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
     }, {
@@ -1084,190 +2055,1134 @@ var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
       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 = []) {
-    var _a, _b, _c, _d, _e, _f;
-    if ((_b = (_a = params.context) == null ? void 0 : _a.resources) == null ? void 0 : _b.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 == null ? void 0 : 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 == null ? void 0 : current.promise) === promise) {
+        this.availabilityRemoteResourceQueryInFlight.delete(queryKey);
+      }
     }
-    if ((_c = params.rawResources) == null ? void 0 : _c.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: ((_d = params.context) == null ? void 0 : _d.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, import_lodash_es.cloneDeep)(params.fallbackResources) : {
         resources: [],
-        externalEvents: ((_e = params.context) == null ? void 0 : _e.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()
     });
-    return {
-      resources: materialized.resources,
-      externalEvents: [
-        ...((_f = params.context) == null ? void 0 : _f.externalEvents) || [],
-        ...materialized.externalEvents
-      ]
-    };
   }
-  /**
-   * 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 || {},
-      products,
-      resources: plannerResources.resources,
-      externalEvents: plannerResources.externalEvents
-    };
-    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 || []
+  resolveEditingOccupancyExclusions(tempOrder, productLineUids = []) {
+    const productUids = /* @__PURE__ */ new Set();
+    const bookingUids = /* @__PURE__ */ new Set();
+    const scheduleEventIds = /* @__PURE__ */ new Set();
+    if (!productLineUids.length)
+      return { productUids, bookingUids, scheduleEventIds };
+    const products = Array.isArray(tempOrder == null ? void 0 : tempOrder.products) ? tempOrder.products : [];
+    const bookings = Array.isArray(tempOrder == null ? void 0 : tempOrder.bookings) ? tempOrder.bookings : [];
+    productLineUids.forEach((requestedUid) => {
+      var _a;
+      const product = products.find((line) => getProductLineUid(line) === String(requestedUid));
+      if (!product) {
+        throw new import_ResourcePlanner.AvailabilityError(
+          "SELF_EXCLUSION_RESOLVE_FAILED",
+          "无法解析编辑商品行，不能安全排除自身占用",
+          { productLineUid: requestedUid }
+        );
+      }
+      const productUid = getProductLineUid(product);
+      const linkedBookingUid = String(product.booking_uid ?? ((_a = product.metadata) == null ? void 0 : _a.booking_uid) ?? "");
+      const linkedBookings = bookings.filter((booking) => linkedBookingUid && getBookingUid(booking) === linkedBookingUid || productUid && String(booking.product_uid ?? "") === productUid);
+      if (!productUid || !linkedBookings.length) {
+        throw new import_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));
+        }
+      });
     });
-    await this.core.effects.emit(`${this.name}:${import_types.UnifiedBookingSalesHooks.onPlannerContextLoaded}`, snapshot);
-    return this.getPlanner().getSnapshot();
+    return { productUids, bookingUids, scheduleEventIds };
   }
-  /** Returns cells, date summaries and a derived grid; cells are continuous ranges, not UI slots. */
-  async queryPlannerAvailability(query = {}) {
-    return this.getPlanner().queryAvailability(query);
+  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;
   }
-  /** Turns compatible availability ranges into user-selectable intervals and ready-to-commit assignments. */
-  resolveAssignableSlots(query = {}) {
-    return this.getPlanner().resolveAssignableSlots(query);
+  collectCartResourceOccupancies(tempOrder, exclusions) {
+    const bookings = Array.isArray(tempOrder == null ? void 0 : tempOrder.bookings) ? tempOrder.bookings : [];
+    return bookings.flatMap((booking) => {
+      var _a;
+      const bookingUid = getBookingUid(booking);
+      const productUid = String(booking.product_uid ?? ((_a = booking.metadata) == null ? void 0 : _a.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 || void 0,
+          productUid: productUid || void 0,
+          raw: { booking, resource }
+        };
+        return this.occupancyIsExcluded(occupancy, exclusions) ? [] : [occupancy];
+      });
+    });
   }
-  /** Stores a UI choice only. It is deliberately side-effect free with respect to tempOrder. */
-  setPlannerSelection(patch) {
-    return this.getPlanner().setSelectionPatch(patch);
+  getCurrentOrderRevision() {
+    return resolveOrderRevision(this.getTempOrder());
   }
-  /**
-   * 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);
+  getAvailabilityContextEntry(contextId) {
+    const context = this.availabilityContextRegistry.get(contextId);
+    if (!context) {
+      throw this.createAvailabilityFacadeError(
+        "AVAILABILITY_CONTEXT_NOT_FOUND",
+        "availability context 不存在或已失效，请重新 prepare",
+        {
+          contextId,
+          lifecycleGeneration: this.availabilityLifecycleGeneration
+        }
+      );
     }
-    return this.getPlanner().getSnapshot();
+    this.touchAvailabilityContext(context);
+    return context;
   }
-  /** Rechecks remote events, capacity and conflicts among the current selection before committing. */
-  validatePlannerSelection() {
-    return this.getPlanner().validateSelection();
+  getAvailabilityProjectionByKey(projectionKey) {
+    var _a;
+    if (!projectionKey)
+      return null;
+    return ((_a = this.availabilityProjectionPool.get(projectionKey)) == null ? void 0 : _a.projection) || null;
+  }
+  getActiveAvailabilityProjectionEntry(context) {
+    if (!context.activeProjectionKey)
+      return null;
+    const entry = this.availabilityProjectionPool.get(context.activeProjectionKey);
+    if (!entry)
+      return null;
+    return this.touchAvailabilityProjection(entry);
   }
-  /** Read-only snapshot for UI diagnostics and progressive flow steps. */
-  getPlannerSnapshot() {
-    return this.getPlanner().getSnapshot();
+  decorateAvailabilityCandidate(contextId, contextVersion, candidate) {
+    return {
+      ...candidate,
+      availabilityContextId: contextId,
+      availabilityContextVersion: contextVersion
+    };
   }
-  /**
-   * 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);
+  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
+        }
+      );
     }
-    if (params.assignments) {
-      this.setPlannerSelection({ assignments: params.assignments });
+  }
+  assertContextualQueryFreshness(context, request) {
+    if (request.target === "time") {
+      request.candidates.forEach((candidate) => {
+        this.assertAvailabilityCandidateFreshness(context, candidate);
+      });
+      return;
     }
-    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"
-          }]
+    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 == null ? void 0 : 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 == null ? void 0 : previousContext.createdAt) ?? params.projection.meta.preparedAt,
+      lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastKnownOrderRevision: params.orderRevision,
+      lastPreparedAt: params.projection.meta.preparedAt,
+      lastSnapshotId: params.projection.meta.snapshotId,
+      durationCandidateAnchorAt: (previousContext == null ? void 0 : previousContext.durationCandidateAnchorAt) ?? this.getAvailabilityDurationCandidateAnchorAt(params.projection),
+      refreshNonce: (previousContext == null ? void 0 : 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,
+      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, import_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
+    };
+  }
+  async getSharedPreparedAvailabilitySnapshot(params) {
+    const lifecycleGeneration = this.availabilityLifecycleGeneration;
+    const normalizedParams = this.normalizeAvailabilityPrepareDescriptor(params);
+    const hasRawInputs = params.rawProducts !== void 0 || params.rawResources !== void 0 || params.rawOccupancies !== void 0;
+    const prepareKey = hasRawInputs ? JSON.stringify(stableValue({
+      scope: this.getAvailabilityScopeDescriptor(),
+      prepare: {
+        ...normalizedParams,
+        rawProducts: void 0,
+        rawResources: void 0,
+        rawOccupancies: void 0
+      },
+      rawInputs: {
+        products: params.rawProducts !== void 0,
+        resources: params.rawResources !== void 0,
+        occupancies: params.rawOccupancies !== void 0
+      }
+    })) : 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 == null ? void 0 : 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 == null ? void 0 : 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);
+      }
     }
-    const validation = this.validatePlannerSelection();
-    if (!validation.ok) {
+  }
+  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 {
-        tempOrder: this.getTempOrder(),
-        assignments,
-        validation
+        context: this.getAvailabilityContextEntry(contextId),
+        projectionEntry: refreshedProjectionEntry,
+        refreshed: true
       };
     }
-    const productsById = new Map(
-      snapshot.context.products.map((product) => [String(product.id), product])
+    throw new import_ResourcePlanner.AvailabilityError("STALE_PROJECTION", "availability projection 刷新期间购物车持续变化，请重新 prepare", {
+      contextId,
+      reason
+    });
+  }
+  async tryAcquireAvailabilityCommitLock(contextId) {
+    if (this.availabilityCommitLocks.has(contextId)) {
+      const waitingContext = this.availabilityContextRegistry.get(contextId);
+      await this.emitAvailabilityDiagnostic({
+        action: "commit_lock_wait",
+        contextId,
+        contextVersion: (waitingContext == null ? void 0 : waitingContext.activeVersion) ?? null,
+        projection: this.getAvailabilityProjectionByKey(waitingContext == null ? void 0 : waitingContext.activeProjectionKey),
+        snapshotId: waitingContext == null ? void 0 : waitingContext.lastSnapshotId,
+        orderRevision: waitingContext == null ? void 0 : 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 == null ? void 0 : currentContext.activeVersion) ?? null,
+      projection: this.getAvailabilityProjectionByKey(currentContext == null ? void 0 : currentContext.activeProjectionKey),
+      snapshotId: currentContext == null ? void 0 : currentContext.lastSnapshotId,
+      orderRevision: currentContext == null ? void 0 : 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 == null ? void 0 : releasedContext.activeVersion) ?? null,
+      projection: this.getAvailabilityProjectionByKey(releasedContext == null ? void 0 : releasedContext.activeProjectionKey),
+      snapshotId: releasedContext == null ? void 0 : releasedContext.lastSnapshotId,
+      orderRevision: releasedContext == null ? void 0 : releasedContext.lastKnownOrderRevision,
+      reason: "commit_end"
+    });
+  }
+  /** 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}:${import_types.UnifiedBookingSalesHooks.onAvailabilityProjectionPrepared}`,
+      payload
+    );
+    return handle;
+  }
+  /** Pure configuration calculation over the current context projection. */
+  async getProductTimeRanges(contextId, request = {}) {
+    const { context, projectionEntry } = await this.ensureAvailabilityContextProjection(
+      contextId,
+      "get_product_time_ranges"
     );
-    await this.removeExistingStagedLines("unified_booking_sales");
-    const assignmentGroups = /* @__PURE__ */ new Map();
-    assignments.forEach((assignment) => {
-      const key = buildAssignmentGroupKey(assignment);
-      assignmentGroups.set(key, [...assignmentGroups.get(key) || [], assignment]);
+    const contextVersion = context.activeVersion;
+    return (0, import_ResourcePlanner.getProductTimeRanges)(projectionEntry.projection, request).map((group) => ({
+      ...group,
+      ranges: group.ranges.map((candidate) => this.decorateAvailabilityCandidate(context.contextId, contextVersion, candidate))
+    }));
+  }
+  /** 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, import_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) {
+    var _a;
+    const context = this.availabilityContextRegistry.get(contextId);
+    if (!context)
+      return;
+    this.removeAvailabilityContext(contextId);
+    void this.emitAvailabilityDiagnostic({
+      action: "release",
+      contextId,
+      contextVersion: context.activeVersion,
+      projection: ((_a = this.getActiveAvailabilityProjectionEntry(context)) == null ? void 0 : _a.projection) || null,
+      snapshotId: context.lastSnapshotId,
+      orderRevision: context.lastKnownOrderRevision,
+      reason: "explicit_release"
     });
-    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 productInput = this.buildUnifiedOrderProduct(
-        sourceProduct,
-        "unified_booking_sales",
-        product
+  }
+  assertAvailabilityCommitWriteCAS(params) {
+    const context = this.availabilityContextRegistry.get(params.contextId);
+    if (!context) {
+      throw this.createAvailabilityFacadeError(
+        "AVAILABILITY_CONTEXT_NOT_FOUND",
+        "availability context 不存在或已失效，请重新 prepare",
+        { contextId: params.contextId }
       );
-      if (!productInput)
-        continue;
-      await this.addProductToOrder(productInput, buildBookingFromAssignments({
-        assignments: groupAssignments,
-        product
-      }));
     }
-    let submitResult;
-    if (params.submitAfterCommit) {
-      submitResult = await this.submitSalesOrder();
+    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;
+  }
+  findProductLineByUid(productLineUid) {
+    var _a;
+    return (((_a = this.getTempOrder()) == null ? void 0 : _a.products) || []).find((product) => getProductLineUid(product) === String(productLineUid));
+  }
+  findLinkedBooking(product) {
+    var _a, _b;
+    const productUid = getProductLineUid(product);
+    const bookingUid = String(product.booking_uid ?? ((_a = product.metadata) == null ? void 0 : _a.booking_uid) ?? "");
+    return (((_b = this.getTempOrder()) == null ? void 0 : _b.bookings) || []).find((booking) => bookingUid && getBookingUid(booking) === bookingUid || productUid && String(booking.product_uid ?? "") === productUid);
+  }
+  /** Revalidates against the latest landed occupancy cache, then mutates exactly one product line. */
+  async commitAvailabilitySelection(contextId, params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const normalizedContextId = String(contextId || "").trim();
+    if (!normalizedContextId) {
+      throw new import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", "commitAvailabilitySelection 缺少 contextId", {
+        candidate: params.candidate
+      });
+    }
+    await this.tryAcquireAvailabilityCommitLock(normalizedContextId);
+    try {
+      const bookingCount = Number(params.bookingCount ?? 1);
+      if (!Number.isInteger(bookingCount) || bookingCount <= 0) {
+        throw new import_ResourcePlanner.AvailabilityError("INVALID_RESERVATION_QUANTITY", "bookingCount 必须是正整数", {
+          bookingCount: params.bookingCount
+        });
+      }
+      if (params.mode === "edit" && bookingCount !== 1) {
+        throw new import_ResourcePlanner.AvailabilityError("INVALID_RESERVATION_QUANTITY", "编辑预约商品时 bookingCount 必须为 1", {
+          bookingCount
+        });
+      }
+      const orderProductQuantity = ((_a = params.orderProduct) == null ? void 0 : _a.num) ?? ((_b = params.orderProduct) == null ? void 0 : _b.quantity) ?? ((_d = (_c = params.orderProduct) == null ? void 0 : _c._extend) == null ? void 0 : _d.quantity);
+      if (orderProductQuantity !== void 0 && orderProductQuantity !== null && Number(orderProductQuantity) !== bookingCount) {
+        throw new import_ResourcePlanner.AvailabilityError("INVALID_RESERVATION_QUANTITY", "orderProduct 数量与 bookingCount 不一致", {
+          bookingCount,
+          orderProductQuantity
+        });
+      }
+      const partySize = Number(params.partySize);
+      if (!Number.isInteger(partySize) || partySize <= 0) {
+        throw new import_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 = ((_e = params.orderProduct) == null ? void 0 : _e.product_id) ?? ((_f = params.orderProduct) == null ? void 0 : _f.id);
+      if (!sameAvailabilityId(orderProductId, params.candidate.productId)) {
+        throw new import_ResourcePlanner.AvailabilityError("INVALID_TARGET_FILTER", "orderProduct 与 candidate 商品不一致", {
+          orderProductId,
+          candidateProductId: params.candidate.productId
+        });
+      }
+      if (params.mode === "edit" && !params.productLineUid) {
+        throw new import_ResourcePlanner.AvailabilityError("PRODUCT_LINE_NOT_FOUND", "edit 模式必须提供 productLineUid");
+      }
+      const editingLine = params.mode === "edit" ? this.findProductLineByUid(String(params.productLineUid)) : void 0;
+      if (params.mode === "edit" && !editingLine) {
+        throw new import_ResourcePlanner.AvailabilityError("PRODUCT_LINE_NOT_FOUND", "找不到要编辑的预约商品行", {
+          productLineUid: params.productLineUid
+        });
+      }
+      if (editingLine && !sameAvailabilityId(editingLine.product_id ?? editingLine.id, params.candidate.productId)) {
+        throw new import_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 import_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 prepareParams = baseProjection.meta.prepareParams;
+      if (!prepareParams) {
+        throw new import_ResourcePlanner.AvailabilityError("REVALIDATION_FAILED", "projection 缺少 prepareParams，无法执行缓存重校验");
+      }
+      const fallbackResources = {
+        resources: (0, import_lodash_es.cloneDeep)([...baseProjection.resources || []]),
+        resourceOccupancies: (0, import_lodash_es.cloneDeep)(
+          [...baseProjection.resourceOccupancies || []].filter((occupancy) => occupancy.source !== "cart")
+        ),
+        includesInjectedRawOccupancies: true
+      };
+      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 refreshedRanges = (0, import_ResourcePlanner.getProductTimeRanges)(refreshedProjection, {
+        productIds: [params.candidate.productId],
+        dateRange: {
+          startDate: params.candidate.startAt.slice(0, 10),
+          endDate: params.candidate.startAt.slice(0, 10)
+        }
+      }).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 import_ResourcePlanner.AvailabilityError("REVALIDATION_FAILED", "缓存重校验后候选时间已不在商品配置中", {
+          contextId: normalizedContextId,
+          candidate: params.candidate,
+          refreshedSnapshotId: refreshedProjection.meta.snapshotId
+        });
+      }
+      const validation = (0, import_ResourcePlanner.validateAvailabilitySelection)(refreshedProjection, {
+        candidate: refreshedCandidateBase,
+        requirementSelections: params.requirementSelections,
+        partySize,
+        bookingCount
+      });
+      if (!validation.ok) {
+        const capacityConflict = validation.conflicts.find((conflict) => conflict.code === "resource_capacity_exceeded");
+        throw new import_ResourcePlanner.AvailabilityError(
+          "REVALIDATION_FAILED",
+          (capacityConflict == null ? void 0 : capacityConflict.message) || "缓存重校验后资源已不可提交",
+          {
+            validation,
+            refreshedSnapshotId: refreshedProjection.meta.snapshotId
+          }
+        );
+      }
+      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 refreshedCandidate = this.decorateAvailabilityCandidate(
+        normalizedContextId,
+        revalidatedContext.activeVersion,
+        refreshedCandidateBase
+      );
+      const product = refreshedProjection.products.find((item) => sameAvailabilityId(item.id, refreshedCandidate.productId));
+      if (!product) {
+        throw new import_ResourcePlanner.AvailabilityError("REVALIDATION_FAILED", "缓存重校验后商品不在 projection 中", {
+          productId: refreshedCandidate.productId
+        });
+      }
+      const existingBooking = editingLine ? this.findLinkedBooking(editingLine) : void 0;
+      const existingBookingUid = existingBooking ? getBookingUid(existingBooking) : "";
+      if (params.mode === "edit" && !existingBookingUid) {
+        throw new import_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 || void 0
+      });
+      const transformed = this.buildUnifiedOrderProduct({
+        ...params.orderProduct,
+        num: bookingCount,
+        quantity: bookingCount
+      }, "unified_booking_sales", product);
+      if (!transformed) {
+        throw new import_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
+        });
+        productLineUid = params.productLineUid;
+        bookingUid = existingBookingUid;
+        productLineUids = [productLineUid];
+        bookingUids = [bookingUid];
+      } else {
+        const beforeProductLineUids = new Set(
+          (((_g = this.getTempOrder()) == null ? void 0 : _g.products) || []).map((line) => getProductLineUid(line)).filter(Boolean)
+        );
+        const beforeBookingUids = new Set(
+          (((_h = this.getTempOrder()) == null ? void 0 : _h.bookings) || []).map((item) => getBookingUid(item)).filter(Boolean)
+        );
+        const products = await this.addProductToOrder(transformed, booking);
+        const addedLines = products.filter((line) => {
+          var _a2;
+          return sameAvailabilityId(line.product_id ?? line.id, refreshedCandidate.productId) && ((_a2 = line.metadata) == null ? void 0 : _a2.availability_candidate_key) === refreshedCandidate.key && !beforeProductLineUids.has(getProductLineUid(line));
+        });
+        productLineUids = addedLines.map((line) => getProductLineUid(line)).filter(Boolean);
+        const addedBookings = (((_i = this.getTempOrder()) == null ? void 0 : _i.bookings) || []).filter((item) => {
+          var _a2;
+          return ((_a2 = item.metadata) == null ? void 0 : _a2.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) => {
+            var _a2;
+            return String(
+              line.booking_uid ?? ((_a2 = line.metadata) == null ? void 0 : _a2.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}:${import_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}:${import_types.UnifiedBookingSalesHooks.onPlannerCommitted}`, result);
-    return result;
   }
 };
 var UnifiedBookingSales = UnifiedBookingSalesImpl;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AvailabilityError,
   UnifiedBookingSales,
   UnifiedBookingSalesImpl,
-  buildBookingFromAssignment,
-  buildBookingFromAssignments,
+  buildAvailabilityLineIdentity,
+  buildAvailabilityResourcesFromV2,
+  buildBookingFromAvailabilityAssignment,
+  buildBookingFromAvailabilityAssignments,
   buildPlannerDiscountResult,
-  buildPlannerLineIdentity,
-  buildPlannerResourcesFromV2,
-  collectPlannerResourceIds,
-  normalizeProductForPlanner,
+  collectAvailabilityResourceIds,
+  normalizeProductForAvailability,
   ...require("./types")
 });