@pisell/pisellos 2.2.292 → 2.2.293

package/lib/modules/ResourcePlanner/planner.js

@@ -3,893 +3,1917 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.DEFAULT_RESOURCE_PLANNER_SELECTION = exports.DEFAULT_RESOURCE_PLANNER_CONTEXT = void 0;
-exports.autoAssignResources = autoAssignResources;
-exports.buildDemandIntervals = buildDemandIntervals;
-exports.evaluateResourceForInterval = evaluateResourceForInterval;
-exports.normalizePlannerContext = normalizePlannerContext;
-exports.queryPlannerAvailability = queryPlannerAvailability;
-exports.resolveAssignableSlots = resolveAssignableSlots;
-exports.validateAssignments = validateAssignments;
-var _dayjs = _interopRequireDefault(require("dayjs"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const DEFAULT_RESOURCE_PLANNER_CONTEXT = exports.DEFAULT_RESOURCE_PLANNER_CONTEXT = {
-  products: [],
-  resources: [],
-  externalEvents: [],
-  slotDurationMinutes: 30,
-  businessStartTime: '09:00',
-  businessEndTime: '18:00'
+exports.createAvailabilityProjection = createAvailabilityProjection;
+exports.getProductTimeRanges = getProductTimeRanges;
+exports.queryAvailabilityProjection = queryAvailabilityProjection;
+exports.validateAvailabilitySelection = validateAvailabilitySelection;
+var _types = require("./types");
+var _localClock = require("./localClock");
+const DEFAULT_SLOT_STEP_MINUTES = 30;
+const DEFAULT_BUSINESS_HOURS = {
+  startTime: '00:00',
+  endTime: '00:00'
 };
-const DEFAULT_RESOURCE_PLANNER_SELECTION = exports.DEFAULT_RESOURCE_PLANNER_SELECTION = {
-  productIds: [],
-  resourceIds: [],
-  assignments: []
-};
-function normalizePlannerContext(input = {}) {
-  return {
-    products: Array.isArray(input.products) ? input.products : [],
-    resources: Array.isArray(input.resources) ? input.resources : [],
-    externalEvents: Array.isArray(input.externalEvents) ? input.externalEvents : [],
-    slotDurationMinutes: input.slotDurationMinutes || DEFAULT_RESOURCE_PLANNER_CONTEXT.slotDurationMinutes,
-    businessStartTime: input.businessStartTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessStartTime,
-    businessEndTime: input.businessEndTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessEndTime
-  };
+function availabilityError(code, message, details) {
+  return new _types.AvailabilityError(code, message, details);
 }
 function sameId(left, right) {
+  if (left === undefined || left === null || right === undefined || right === null) return false;
   return String(left) === String(right);
 }
-function dateOf(value) {
-  return (0, _dayjs.default)(value).format('YYYY-MM-DD');
-}
-function timeOf(value) {
-  return (0, _dayjs.default)(value).format('HH:mm');
-}
-function toDateTime(date, time) {
-  if (/^\d{4}-\d{2}-\d{2}/.test(time)) return (0, _dayjs.default)(time);
-  return (0, _dayjs.default)(`${date} ${time.length === 5 ? `${time}:00` : time}`);
-}
-function overlaps(startA, endA, startB, endB) {
-  return startA.isBefore(endB) && endA.isAfter(startB);
-}
-function containsRange(outerStart, outerEnd, innerStart, innerEnd) {
-  return !innerStart.isBefore(outerStart) && !innerEnd.isAfter(outerEnd);
-}
-function maxDayjs(left, right) {
-  return left.isAfter(right) ? left : right;
-}
-function minDayjs(left, right) {
-  return left.isBefore(right) ? left : right;
-}
-function addDays(start, end) {
-  const result = [];
-  let cursor = (0, _dayjs.default)(start);
-  const finalDay = (0, _dayjs.default)(end);
-  while (!cursor.isAfter(finalDay, 'day')) {
-    result.push(cursor.format('YYYY-MM-DD'));
-    cursor = cursor.add(1, 'day');
-  }
-  return result;
-}
-function getQueryProducts(products, query) {
-  if (!query.productIds?.length) return products;
-  return products.filter(product => query.productIds.some(id => sameId(id, product.id)));
-}
-function getQueryResources(resources, query) {
-  if (!query.resourceIds?.length) return resources;
-  return resources.filter(resource => query.resourceIds.some(id => sameId(id, resource.id)));
-}
-function matchesResourceRequirement(resource, requirement) {
-  const isFormlessCandidate = resource.formId == null;
-  const formMatches = requirement.formId == null || isFormlessCandidate || sameId(requirement.formId, resource.formId);
-  const resourceMatches = !requirement.resourceIds?.length || isFormlessCandidate || requirement.resourceIds.some(id => sameId(id, resource.id));
-  return formMatches && resourceMatches;
-}
-function resolveProductTitle(product) {
-  const rawTitle = product.raw?.title || product.raw?.name || product.raw?.product_title;
-  if (typeof product.title === 'string') return product.title;
-  if (typeof rawTitle === 'string') return rawTitle;
-  if (rawTitle && typeof rawTitle === 'object') {
-    return rawTitle.en || rawTitle.zh || rawTitle.default || Object.values(rawTitle)[0];
-  }
-  return undefined;
-}
-function buildDemandIntervals(products, query, context) {
-  const dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : [];
-  const selectedProducts = getQueryProducts(products, query);
-  const intervals = [];
-  for (const product of selectedProducts) {
-    const quantity = Math.max(1, Number(product.quantity || 1));
-    const capacityRequired = Math.max(1, Number(query.pax || product.capacityRequired || 1));
-    const requirements = product.resourceRequirements || [];
-    if (product.kind === 'session' || product.kind === 'venue_slot') {
-      const schedules = product.schedule || [];
-      for (const schedule of schedules) {
-        const scheduleDate = dateOf(schedule.start_at);
-        if (dates.length > 0 && !dates.includes(scheduleDate)) continue;
-        const start = (0, _dayjs.default)(schedule.start_at);
-        const end = (0, _dayjs.default)(schedule.end_at);
-        intervals.push({
-          id: `${product.id}:${start.toISOString()}:${end.toISOString()}`,
-          productId: product.id,
-          source: product.kind,
-          date: dateOf(schedule.start_at),
-          start_at: start.toISOString(),
-          end_at: end.toISOString(),
-          durationMinutes: Math.max(1, end.diff(start, 'minute')),
-          quantity,
-          capacityRequired,
-          resourceRequirements: requirements
-        });
-      }
-      continue;
-    }
-    if (product.kind === 'duration') {
-      const duration = Math.max(1, Number(product.durationMinutes || 30));
-      for (const currentDate of dates) {
-        const start = query.startTime ? toDateTime(currentDate, query.startTime) : toDateTime(currentDate, context?.businessStartTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessStartTime);
-        let end = query.startTime && query.endTime ? toDateTime(currentDate, query.endTime) : query.startTime ? start.add(duration, 'minute') : toDateTime(currentDate, context?.businessEndTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessEndTime);
-        if (!end.isAfter(start)) end = end.add(1, 'day');
-        intervals.push({
-          id: `${product.id}:${currentDate}:${query.startTime || 'range'}`,
-          productId: product.id,
-          source: 'duration',
-          date: currentDate,
-          start_at: start.toISOString(),
-          end_at: end.toISOString(),
-          durationMinutes: duration,
-          quantity,
-          capacityRequired,
-          resourceRequirements: requirements
-        });
-      }
-    }
+function uniqById(values = []) {
+  const map = new Map();
+  values.forEach(value => {
+    map.set(String(value), value);
+  });
+  return Array.from(map.values());
+}
+function normalizePartySize(partySize) {
+  if (partySize === undefined || partySize === null) return undefined;
+  const normalized = Number(partySize);
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'partySize 必须是正整数', {
+      partySize
+    });
   }
-  return intervals;
+  return normalized;
 }
-function getEventsForResource(resource, contextEvents) {
-  const embeddedEvents = resource.times.flatMap(time => time.event_list || []);
-  return [...embeddedEvents, ...contextEvents.filter(event => sameId(event.resourceId ?? event.resource_id, resource.id))].filter(Boolean);
+function normalizeBookingCount(bookingCount) {
+  if (bookingCount === undefined || bookingCount === null) return 1;
+  const normalized = Number(bookingCount);
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'bookingCount 必须是正整数', {
+      bookingCount
+    });
+  }
+  return normalized;
 }
-function collectEventsByResource(resources, contextEvents) {
-  const eventsByResource = new Map();
-  resources.forEach(resource => {
-    eventsByResource.set(String(resource.id), getEventsForResource(resource, contextEvents));
-  });
-  return eventsByResource;
+function resolveRequestedDurationMinutes(product, request) {
+  const configured = Math.max(1, Number(product.durationMinutes || 30) || 30);
+  if (product.kind !== 'duration') return configured;
+  const override = request.durationMinutesByProductId?.[String(product.id)];
+  const normalized = Number(override);
+  return Number.isInteger(normalized) && normalized > 0 ? normalized : configured;
+}
+function resolveRequestedDurationStartTimes(product, request) {
+  if (product.kind !== 'duration') return [];
+  const values = request.durationStartTimesByProductId?.[String(product.id)];
+  if (!Array.isArray(values)) return [];
+  return Array.from(new Set(values.filter(value => typeof value === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/.test(value))));
+}
+function toDateTime(value, _timezoneName) {
+  try {
+    return (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(value));
+  } catch (_error) {
+    return Number.NaN;
+  }
+}
+function toDateStart(value, _timezoneName) {
+  try {
+    return (0, _localClock.localDateToScalarStart)(value);
+  } catch (_error) {
+    return Number.NaN;
+  }
+}
+function toDateEnd(value, _timezoneName) {
+  const start = toDateStart(value);
+  return Number.isFinite(start) ? (0, _localClock.addLocalCalendarDays)(start, 1) - 1 : Number.NaN;
+}
+function toDateTimeInDate(date, time, _timezoneName) {
+  return toDateTime(`${date}T${time.length === 5 ? `${time}:00` : time}`);
+}
+function addMinutesZoned(value, minutes, _timezoneName) {
+  return (0, _localClock.addLocalMinutes)(value, minutes);
+}
+function ceilToTenMinutes(value, _timezoneName) {
+  return (0, _localClock.ceilLocalScalarToTenMinutes)(value);
+}
+function floorToMinute(value) {
+  return Math.floor(value / 60000) * 60000;
+}
+function nextDate(value, _timezoneName) {
+  return (0, _localClock.nextDate)(value);
 }
-function getWorkingSegmentsForInterval(resource, interval) {
-  const intervalStart = (0, _dayjs.default)(interval.start_at);
-  const intervalEnd = (0, _dayjs.default)(interval.end_at);
-  return resource.times.map(time => {
-    const start = maxDayjs((0, _dayjs.default)(time.start_at), intervalStart);
-    const end = minDayjs((0, _dayjs.default)(time.end_at), intervalEnd);
+function formatDateTime(value, _timezoneName, fixedOffsetMinutes) {
+  return (0, _localClock.formatLocalDateTime)(value, fixedOffsetMinutes ?? (0, _localClock.captureRuntimeOffsetMinutes)());
+}
+function formatDate(value, _timezoneName) {
+  return (0, _localClock.formatLocalDate)(value);
+}
+function formatTime(value, _timezoneName) {
+  return (0, _localClock.formatLocalTime)(value, false);
+}
+function normalizeAbsoluteRange(range, _timezoneName) {
+  const start = toDateTime(range.startAt);
+  const end = toDateTime(range.endAt);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return null;
+  return {
+    start,
+    end
+  };
+}
+function getCandidateBookingRange(candidate) {
+  return {
+    // Runtime fallback keeps older caller-created candidates fail-safe during migration.
+    startAt: candidate.bookingStartAt || candidate.startAt,
+    endAt: candidate.bookingEndAt || candidate.endAt
+  };
+}
+function getCandidateRangeCacheKey(candidate) {
+  const bookingRange = getCandidateBookingRange(candidate);
+  return `${candidate.key}:${bookingRange.startAt}:${bookingRange.endAt}`;
+}
+function getProductTimeRangeIdentity(range) {
+  const bookingRange = getCandidateBookingRange(range);
+  return [String(range.productId), range.startAt, range.endAt, bookingRange.startAt, bookingRange.endAt].join(':');
+}
+function toIndexedRange(range) {
+  return {
+    ...range,
+    startMs: range.start,
+    endMs: range.end
+  };
+}
+function normalizeNonNegativeNumber(value) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized < 0) return null;
+  return normalized;
+}
+function resolveCutOffPolicyIssue(policy) {
+  if (policy.type === 'invalid') {
+    return policy.reason || 'invalid_cutoff_policy';
+  }
+  if ('futureDay' in policy && policy.futureDay !== undefined && normalizeNonNegativeNumber(policy.futureDay) === null) {
+    return 'invalid_future_day';
+  }
+  if (policy.type === 'ongoing' && policy.mode === 'after_start' && normalizeNonNegativeNumber(policy.graceMinutes) === null) {
+    return 'invalid_grace_minutes';
+  }
+  if (policy.type === 'advance') {
+    if (normalizeNonNegativeNumber(policy.unit) === null) return 'invalid_advance_unit';
+    if (!['days', 'hours', 'minutes'].includes(policy.unitType)) return 'invalid_advance_unit_type';
+  }
+  return null;
+}
+function addLeadWindow(base, unit, unitType, _timezoneName) {
+  if (unitType === 'days') return (0, _localClock.addLocalCalendarDays)(base, unit);
+  if (unitType === 'hours') return (0, _localClock.addLocalHours)(base, unit);
+  return (0, _localClock.addLocalMinutes)(base, unit);
+}
+function evaluateCandidateTimeGate(params) {
+  const {
+    product,
+    candidateRange,
+    evaluationContext,
+    timezoneName
+  } = params;
+  const now = evaluationContext.evaluatedAt;
+  if (candidateRange.endMs <= evaluationContext.evaluatedAtMs) {
     return {
-      start,
-      end
+      status: 'past',
+      reasonCodes: ['past'],
+      conflictCode: 'past'
+    };
+  }
+  const policy = product.cutOffPolicy;
+  if (!policy) return null;
+  if (resolveCutOffPolicyIssue(policy)) {
+    return {
+      status: 'unavailable',
+      reasonCodes: ['booking_cutoff_invalid'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
+  if ('futureDay' in policy && policy.futureDay !== undefined) {
+    const futureDay = normalizeNonNegativeNumber(policy.futureDay);
+    const lastAllowedDateOrdinal = (0, _localClock.dateOrdinalFromLocalDate)(formatDate(now)) + futureDay;
+    if ((0, _localClock.dateOrdinalFromLocalDate)(formatDate(candidateRange.start)) > lastAllowedDateOrdinal) {
+      return {
+        status: 'unavailable',
+        reasonCodes: ['booking_cutoff_future_day'],
+        conflictCode: 'booking_cutoff'
+      };
+    }
+  }
+  if (policy.type === 'ongoing') {
+    if (policy.mode === 'before_end') return null;
+    const graceMinutes = normalizeNonNegativeNumber(policy.graceMinutes);
+    const graceDeadline = addMinutesZoned(candidateRange.start, graceMinutes, timezoneName);
+    if (now < graceDeadline) return null;
+    return {
+      status: 'unavailable',
+      reasonCodes: ['booking_cutoff_after_start'],
+      conflictCode: 'booking_cutoff'
     };
-  }).filter(segment => segment.end.isAfter(segment.start));
+  }
+  if (policy.type === 'before_start') {
+    if (now < candidateRange.start) return null;
+    return {
+      status: 'unavailable',
+      reasonCodes: ['booking_cutoff_before_start'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
+  if (policy.type === 'advance') {
+    const leadWindow = addLeadWindow(now, normalizeNonNegativeNumber(policy.unit), policy.unitType, timezoneName);
+    if (leadWindow <= candidateRange.start) return null;
+    return {
+      status: 'unavailable',
+      reasonCodes: ['booking_cutoff_advance'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
+  return {
+    status: 'unavailable',
+    reasonCodes: ['booking_cutoff_invalid'],
+    conflictCode: 'booking_cutoff'
+  };
 }
-function mergeBusySegments(segments) {
-  const sorted = [...segments].filter(segment => segment.end.isAfter(segment.start)).sort((left, right) => left.start.valueOf() - right.start.valueOf());
+function overlaps(left, right) {
+  return left.start < right.end && left.end > right.start;
+}
+function contains(outer, inner) {
+  return inner.start >= outer.start && inner.end <= outer.end;
+}
+function clipRange(base, clip) {
+  const start = Math.max(base.start, clip.start);
+  const end = Math.min(base.end, clip.end);
+  if (end <= start) return null;
+  return {
+    start,
+    end
+  };
+}
+function sortRanges(ranges) {
+  return [...ranges].sort((left, right) => left.start - right.start);
+}
+function mergeRanges(ranges) {
+  const sorted = sortRanges(ranges);
   const merged = [];
-  sorted.forEach(segment => {
-    const previous = merged[merged.length - 1];
-    if (previous && !segment.start.isAfter(previous.end)) {
-      previous.end = maxDayjs(previous.end, segment.end);
-    } else {
-      merged.push({
-        ...segment
-      });
+  sorted.forEach(range => {
+    const last = merged[merged.length - 1];
+    if (!last) {
+      merged.push(range);
+      return;
     }
+    if (range.start <= last.end) {
+      last.end = Math.max(range.end, last.end);
+      return;
+    }
+    merged.push(range);
   });
   return merged;
 }
-function subtractBusyIntervals(workingSegments, events) {
-  const available = [];
-  workingSegments.forEach(working => {
-    const busySegments = mergeBusySegments(events.filter(event => overlaps(working.start, working.end, (0, _dayjs.default)(event.start_at), (0, _dayjs.default)(event.end_at))).map(event => ({
-      start: maxDayjs((0, _dayjs.default)(event.start_at), working.start),
-      end: minDayjs((0, _dayjs.default)(event.end_at), working.end)
-    })));
-    let cursor = working.start;
-    busySegments.forEach(busy => {
-      if (busy.start.isAfter(cursor)) {
-        available.push({
-          start: cursor,
-          end: busy.start
-        });
-      }
-      if (busy.end.isAfter(cursor)) cursor = busy.end;
+function intersectRangeLists(left, right) {
+  const results = [];
+  left.forEach(leftRange => {
+    right.forEach(rightRange => {
+      const clipped = clipRange(leftRange, rightRange);
+      if (clipped) results.push(clipped);
     });
-    if (working.end.isAfter(cursor)) {
-      available.push({
-        start: cursor,
-        end: working.end
-      });
-    }
   });
-  return available;
+  return mergeRanges(results);
 }
-function buildCapacityRanges(params) {
-  const {
-    workingSegments,
-    events,
-    maxCapacity,
-    requiredCapacity
-  } = params;
-  const ranges = [];
-  workingSegments.forEach(working => {
-    const boundaries = new Map([[working.start.valueOf(), working.start], [working.end.valueOf(), working.end]]);
-    events.forEach(event => {
-      const eventStart = (0, _dayjs.default)(event.start_at);
-      const eventEnd = (0, _dayjs.default)(event.end_at);
-      if (!overlaps(working.start, working.end, eventStart, eventEnd)) return;
-      const clippedStart = maxDayjs(eventStart, working.start);
-      const clippedEnd = minDayjs(eventEnd, working.end);
-      boundaries.set(clippedStart.valueOf(), clippedStart);
-      boundaries.set(clippedEnd.valueOf(), clippedEnd);
+function enumerateDates(startDate, endDate) {
+  const dates = [];
+  let cursor = startDate;
+  while (cursor <= endDate) {
+    dates.push(cursor);
+    cursor = nextDate(cursor);
+  }
+  return dates;
+}
+function normalizeCoverage(input) {
+  const startDate = input.coverage.startDate;
+  const endDate = input.coverage.endDate;
+  const isCanonicalDate = value => {
+    try {
+      return (0, _localClock.formatLocalDate)((0, _localClock.parseLocalDate)(value)) === value;
+    } catch (_error) {
+      return false;
+    }
+  };
+  if (!startDate || !endDate || !isCanonicalDate(startDate) || !isCanonicalDate(endDate)) {
+    throw availabilityError('INVALID_DATE_RANGE', 'coverage.startDate / coverage.endDate 非法', {
+      coverage: input.coverage
     });
-    const points = Array.from(boundaries.values()).sort((left, right) => left.valueOf() - right.valueOf());
-    for (let index = 0; index < points.length - 1; index += 1) {
-      const start = points[index];
-      const end = points[index + 1];
-      if (!end.isAfter(start)) continue;
-      const usedCapacity = events.filter(event => overlaps(start, end, (0, _dayjs.default)(event.start_at), (0, _dayjs.default)(event.end_at))).reduce((sum, event) => sum + Math.max(1, Number(event.pax || 1)), 0);
-      const remainingCapacity = Math.max(0, maxCapacity - usedCapacity);
-      if (remainingCapacity < requiredCapacity) continue;
-      const status = remainingCapacity < maxCapacity ? 'limited' : 'available';
-      const previous = ranges[ranges.length - 1];
-      if (previous && previous.end.isSame(start) && previous.remainingCapacity === remainingCapacity && previous.maxCapacity === maxCapacity && previous.status === status) {
-        previous.end = end;
-      } else {
-        ranges.push({
-          start,
-          end,
-          remainingCapacity,
-          maxCapacity,
-          status
-        });
-      }
+  }
+  if (endDate < startDate) {
+    throw availabilityError('INVALID_DATE_RANGE', 'coverage.endDate 不能早于 startDate', {
+      coverage: input.coverage
+    });
+  }
+  return {
+    dateRange: {
+      startDate,
+      endDate
+    },
+    absolute: {
+      start: toDateStart(startDate, input.timezone),
+      end: toDateEnd(nextDate(endDate, input.timezone), input.timezone)
     }
-  });
-  return ranges;
+  };
 }
-function rangeFitsDuration(segment, durationMinutes) {
-  return segment.end.diff(segment.start, 'minute') >= durationMinutes;
+function normalizeResourceWindow(resource, coverage, timezoneName) {
+  return mergeRanges((resource.windows || []).map(window => normalizeAbsoluteRange(window, timezoneName)).filter(window => Boolean(window)).map(window => clipRange(window, coverage)).filter(window => Boolean(window)));
 }
-function makeAvailabilityRangeCell(params) {
-  const {
-    interval,
-    resource,
-    segment
-  } = params;
-  const maxCapacity = Math.max(1, Number(segment.maxCapacity || resource.capacity || 1));
-  const remainingCapacity = resource.resourceType === 'single' ? 1 : Math.max(0, Number(segment.remainingCapacity ?? maxCapacity));
-  const status = resource.resourceType === 'single' ? 'available' : segment.status || (remainingCapacity < maxCapacity ? 'limited' : 'available');
+function normalizeOccupancy(occupancy, coverage, timezoneName, fixedOffsetMinutes) {
+  const normalized = normalizeAbsoluteRange(occupancy, timezoneName);
+  if (!normalized) return null;
+  const clipped = clipRange(normalized, coverage);
+  if (!clipped) return null;
   return {
-    key: `${interval.productId}:${resource.id}:${segment.start.toISOString()}:${segment.end.toISOString()}`,
-    productId: interval.productId,
-    resourceId: resource.id,
-    date: interval.date,
-    start_at: segment.start.toISOString(),
-    end_at: segment.end.toISOString(),
-    startTime: segment.start.format('HH:mm'),
-    endTime: segment.end.format('HH:mm'),
-    durationMinutes: interval.durationMinutes,
-    cellType: 'availability_range',
-    status,
-    remainingCapacity,
-    maxCapacity,
-    reasonCodes: [],
-    conflicts: []
+    ...occupancy,
+    startAt: formatDateTime(clipped.start, timezoneName, fixedOffsetMinutes),
+    endAt: formatDateTime(clipped.end, timezoneName, fixedOffsetMinutes),
+    pax: Math.max(1, Number(occupancy.pax || 1) || 1)
   };
 }
-function buildAvailabilityCellsForResource(params) {
-  const {
-    resource,
-    interval,
-    events
-  } = params;
-  const requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
-  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
-  const maxCapacity = Math.max(1, Number(resource.capacity || 1));
-  let workingSegments = getWorkingSegmentsForInterval(resource, interval);
-  const now = (0, _dayjs.default)();
-  workingSegments = workingSegments.map(segment => ({
-    start: segment.end.isAfter(now) ? maxDayjs(segment.start, now) : segment.start,
-    end: segment.end
-  })).filter(segment => segment.end.isAfter(segment.start));
-  const availableSegments = resource.resourceType === 'single' ? subtractBusyIntervals(workingSegments, events).map(segment => ({
-    ...segment,
-    remainingCapacity: 1,
-    maxCapacity: 1,
-    status: 'available'
-  })) : buildCapacityRanges({
-    workingSegments,
-    events,
-    maxCapacity,
-    requiredCapacity
+function normalizeRequirementGroup(product, requirementGroup) {
+  const resourceType = 'single';
+  const required = requirementGroup.required !== false;
+  const min = required ? 1 : 0;
+  return {
+    ...requirementGroup,
+    id: requirementGroup.id || `group:${String(product.id)}:${String(requirementGroup.formId ?? resourceType)}`,
+    resourceType,
+    required,
+    min,
+    max: 1,
+    resourceIds: uniqById(requirementGroup.resourceIds || []),
+    capacityRequired: Math.max(1, Number(requirementGroup.capacityRequired || product.capacityRequired || 1) || 1)
+  };
+}
+function normalizeProducts(products) {
+  return products.map(product => ({
+    ...product,
+    quantity: Math.max(1, Number(product.quantity || 1) || 1),
+    capacityRequired: Math.max(1, Number(product.capacityRequired || 1) || 1),
+    durationMinutes: Math.max(1, Number(product.durationMinutes || 30) || 30),
+    cutOffPolicy: product.cutOffPolicy ? {
+      ...product.cutOffPolicy
+    } : undefined,
+    requirementGroups: (product.requirementGroups || []).map(group => normalizeRequirementGroup(product, group)),
+    sessionRules: (product.sessionRules || []).map(rule => ({
+      ...rule,
+      weekdays: rule.weekdays ? [...rule.weekdays] : undefined,
+      dates: rule.dates ? [...rule.dates] : undefined,
+      includeDates: rule.includeDates ? [...rule.includeDates] : undefined,
+      excludeDates: rule.excludeDates ? [...rule.excludeDates] : undefined,
+      scheduleRef: rule.scheduleRef ? {
+        ...rule.scheduleRef
+      } : undefined
+    })),
+    sessionRanges: (product.sessionRanges || []).map(range => ({
+      ...range,
+      scheduleRefs: range.scheduleRefs?.map(scheduleRef => ({
+        ...scheduleRef
+      }))
+    }))
+  }));
+}
+function normalizeResources(resources) {
+  return resources.map(resource => ({
+    ...resource,
+    resourceType: 'single',
+    capacity: Math.max(1, Number(resource.capacity || 1) || 1),
+    windows: (resource.windows || []).map(window => ({
+      ...window
+    }))
+  }));
+}
+function normalizeOperatingHours(params) {
+  const fallbackWindows = enumerateDates(params.dateRange.startDate, params.dateRange.endDate).map(date => {
+    const start = toDateTimeInDate(date, params.businessHours.startTime, params.timezoneName);
+    let end = toDateTimeInDate(date, params.businessHours.endTime, params.timezoneName);
+    if (end <= start) {
+      end = toDateTimeInDate(nextDate(date), params.businessHours.endTime, params.timezoneName);
+    }
+    return {
+      start,
+      end
+    };
   });
-  return availableSegments.filter(segment => rangeFitsDuration(segment, durationMinutes)).map(segment => makeAvailabilityRangeCell({
-    interval,
-    resource,
-    segment
+  const sourceWindows = params.input ? params.input.windows : fallbackWindows.map(range => ({
+    startAt: formatDateTime(range.start, params.timezoneName, params.fixedOffsetMinutes),
+    endAt: formatDateTime(range.end, params.timezoneName, params.fixedOffsetMinutes)
+  }));
+  const windows = mergeRanges(sourceWindows.map(window => normalizeAbsoluteRange(window, params.timezoneName)).filter(window => Boolean(window)).map(window => clipRange(window, params.coverage)).filter(window => Boolean(window))).map(range => ({
+    startAt: formatDateTime(range.start, params.timezoneName, params.fixedOffsetMinutes),
+    endAt: formatDateTime(range.end, params.timezoneName, params.fixedOffsetMinutes)
   }));
+  return {
+    source: params.input?.source || params.fallbackSource,
+    scheduleIds: uniqById(params.input?.scheduleIds || []),
+    missingScheduleIds: uniqById(params.input?.missingScheduleIds || []),
+    windows
+  };
 }
-function evaluateResourceForInterval(params) {
-  const {
-    resource,
-    interval,
-    context
-  } = params;
-  const start = (0, _dayjs.default)(interval.start_at);
-  const end = (0, _dayjs.default)(interval.end_at);
-  const conflicts = [];
-  const reasonCodes = [];
-  const maxCapacity = Math.max(1, Number(resource.capacity || 1));
-  const requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
-  if (start.isBefore((0, _dayjs.default)())) {
-    reasonCodes.push('past');
-    conflicts.push({
-      type: 'past',
-      message: '时间已过期',
-      resourceId: resource.id,
-      productId: interval.productId
-    });
+function matchesRequirementGroup(requirementGroup, resource, product, partySize = 1) {
+  if (requirementGroup.formId !== undefined && resource.formId !== undefined && !sameId(requirementGroup.formId, resource.formId)) {
+    return false;
   }
-  const insideResourceTime = resource.times.some(time => {
-    return containsRange((0, _dayjs.default)(time.start_at), (0, _dayjs.default)(time.end_at), start, end);
+  if (requirementGroup.resourceIds?.length && !requirementGroup.resourceIds.some(resourceId => sameId(resourceId, resource.id))) {
+    return false;
+  }
+  return resource.capacity >= resolveRequiredCapacity(requirementGroup, product, partySize);
+}
+function resolveRequiredCapacity(requirementGroup, product, partySize) {
+  return Math.max(1, Number(partySize ?? requirementGroup.capacityRequired ?? product.capacityRequired ?? 1) || 1);
+}
+function buildCellKey(params) {
+  return [String(params.productId), params.groupId, String(params.resourceId), params.start, params.end].join(':');
+}
+function dedupeOccupancyRefKey(occupancy) {
+  if (occupancy.scheduleEventId !== undefined && occupancy.scheduleEventId !== null) {
+    return `scheduleEvent:${String(occupancy.resourceId)}:${String(occupancy.scheduleEventId)}`;
+  }
+  if (occupancy.bookingUid !== undefined && occupancy.bookingUid !== null) {
+    return `bookingUid:${String(occupancy.resourceId)}:${String(occupancy.bookingUid)}`;
+  }
+  if (occupancy.productUid !== undefined && occupancy.productUid !== null) {
+    return `productUid:${String(occupancy.resourceId)}:${String(occupancy.productUid)}`;
+  }
+  return `range:${String(occupancy.resourceId)}:${occupancy.startAt}:${occupancy.endAt}:${String(occupancy.pax || 1)}`;
+}
+function buildCells(projection) {
+  const coverage = {
+    start: toDateTime(projection.meta.coverage.startAt, projection.meta.timezone),
+    end: toDateTime(projection.meta.coverage.endAt, projection.meta.timezone)
+  };
+  const cells = [];
+  const timezoneName = projection.meta.timezone;
+  const fixedOffsetMinutes = (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const projectionNow = toDateTime(projection.meta.now);
+  projection.products.forEach(product => {
+    (product.requirementGroups || []).forEach(requirementGroup => {
+      projection.resources.filter(resource => matchesRequirementGroup(requirementGroup, resource, product)).forEach(resource => {
+        const windows = normalizeResourceWindow(resource, coverage, timezoneName);
+        const occupancies = projection.resourceOccupancies.filter(occupancy => sameId(occupancy.resourceId, resource.id)).map(occupancy => ({
+          occupancy,
+          range: normalizeAbsoluteRange(occupancy, timezoneName)
+        })).filter(item => Boolean(item.range)).map(item => ({
+          ...item,
+          range: clipRange(item.range, coverage)
+        })).filter(item => Boolean(item.range));
+        const boundaries = new Set([coverage.start, coverage.end]);
+        windows.forEach(window => {
+          boundaries.add(window.start);
+          boundaries.add(window.end);
+        });
+        occupancies.forEach(({
+          range
+        }) => {
+          boundaries.add(range.start);
+          boundaries.add(range.end);
+        });
+        const sortedBoundaries = Array.from(boundaries.values()).sort((left, right) => left - right);
+        for (let index = 0; index < sortedBoundaries.length - 1; index += 1) {
+          const start = sortedBoundaries[index];
+          const end = sortedBoundaries[index + 1];
+          if (end <= start) continue;
+          const segment = {
+            start,
+            end
+          };
+          const isInsideWorkingWindow = windows.some(window => contains(window, segment));
+          const segmentOccupancies = isInsideWorkingWindow ? occupancies.filter(({
+            range
+          }) => overlaps(range, segment)).map(({
+            occupancy
+          }) => occupancy) : [];
+          const usedCapacity = segmentOccupancies.reduce((sum, occupancy) => sum + Math.max(1, Number(occupancy.pax || 1) || 1), 0);
+          const remainingCapacity = Math.max(0, resource.capacity - usedCapacity);
+          const requiredCapacity = resolveRequiredCapacity(requirementGroup, product);
+          const reasonCodes = Array.from(new Set(segmentOccupancies.flatMap(occupancy => {
+            const source = occupancy.source || 'remote';
+            if (source === 'selection') return ['selection_occupied'];
+            if (source === 'cart') return ['cart_occupied'];
+            return ['resource_occupied'];
+          })));
+          let status = 'available';
+          if (end <= projectionNow) {
+            status = 'past';
+            reasonCodes.push('past');
+          } else if (!isInsideWorkingWindow) {
+            status = 'unavailable';
+            reasonCodes.push('outside_resource_window');
+          } else if (remainingCapacity < requiredCapacity) {
+            status = 'full';
+            reasonCodes.push('capacity_full');
+          } else if (remainingCapacity < resource.capacity) {
+            status = 'limited';
+          }
+          cells.push({
+            key: buildCellKey({
+              productId: product.id,
+              groupId: requirementGroup.id,
+              resourceId: resource.id,
+              start,
+              end
+            }),
+            productId: product.id,
+            requirementGroupId: requirementGroup.id,
+            requirementFormId: requirementGroup.formId,
+            resourceId: resource.id,
+            resourceName: resource.name,
+            resourceType: resource.resourceType,
+            startAt: formatDateTime(start, timezoneName, fixedOffsetMinutes),
+            endAt: formatDateTime(end, timezoneName, fixedOffsetMinutes),
+            date: formatDate(start, timezoneName),
+            startTime: formatTime(start, timezoneName),
+            endTime: formatTime(end, timezoneName),
+            timezone: projection.meta.timezone,
+            status,
+            // 资源组当前统一单选；具体资源仍用 capacity 表达可承载的预约数量。
+            remainingCapacity,
+            maxCapacity: resource.capacity,
+            reasonCodes: Array.from(new Set(reasonCodes)),
+            occupancyRefs: segmentOccupancies.map(occupancy => ({
+              id: occupancy.id,
+              resourceId: occupancy.resourceId,
+              source: occupancy.source,
+              serverEventId: occupancy.serverEventId,
+              bookingUid: occupancy.bookingUid,
+              productUid: occupancy.productUid,
+              scheduleEventId: occupancy.scheduleEventId
+            }))
+          });
+        }
+      });
+    });
   });
-  if (!insideResourceTime) {
-    reasonCodes.push('outside_resource_time');
-    conflicts.push({
-      type: 'outside_resource_time',
-      message: '所选时间不在资源可用时间内',
-      resourceId: resource.id,
-      productId: interval.productId
+  return compressCells(cells);
+}
+function compressCells(cells) {
+  const sorted = [...cells].sort((left, right) => {
+    const keyLeft = [String(left.productId), String(left.requirementGroupId), String(left.resourceId), left.startAt].join(':');
+    const keyRight = [String(right.productId), String(right.requirementGroupId), String(right.resourceId), right.startAt].join(':');
+    return keyLeft.localeCompare(keyRight);
+  });
+  return sorted.reduce((result, cell) => {
+    const last = result[result.length - 1];
+    if (last && sameId(last.productId, cell.productId) && sameId(last.requirementGroupId, cell.requirementGroupId) && sameId(last.resourceId, cell.resourceId) && last.status === cell.status && last.remainingCapacity === cell.remainingCapacity && last.maxCapacity === cell.maxCapacity && JSON.stringify(last.reasonCodes) === JSON.stringify(cell.reasonCodes) && JSON.stringify(last.occupancyRefs) === JSON.stringify(cell.occupancyRefs) && last.endAt === cell.startAt) {
+      last.endAt = cell.endAt;
+      last.endTime = cell.endTime;
+      return result;
+    }
+    result.push({
+      ...cell
     });
+    return result;
+  }, []);
+}
+function makeCoverageAbsolute(dateRange, timezoneName, fixedOffsetMinutes) {
+  const guardEndDate = nextDate(dateRange.endDate, timezoneName);
+  return {
+    startAt: formatDateTime(toDateStart(dateRange.startDate, timezoneName), timezoneName, fixedOffsetMinutes),
+    endAt: formatDateTime(toDateEnd(guardEndDate, timezoneName), timezoneName, fixedOffsetMinutes)
+  };
+}
+function normalizeProjectionInstant(value, fallbackScalar, timezoneName, fixedOffsetMinutes) {
+  const scalar = value ? toDateTime(value) : fallbackScalar;
+  return formatDateTime(Number.isFinite(scalar) ? scalar : fallbackScalar, timezoneName, fixedOffsetMinutes);
+}
+function cloneSnapshotMetadataValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(item => cloneSnapshotMetadataValue(item));
   }
-  const events = getEventsForResource(resource, context.externalEvents);
-  const overlapping = events.filter(event => overlaps(start, end, (0, _dayjs.default)(event.start_at), (0, _dayjs.default)(event.end_at)));
-  const usedCapacity = resource.resourceType === 'single' ? overlapping.length : overlapping.reduce((sum, event) => sum + Math.max(1, Number(event.pax || 1)), 0);
-  const remainingCapacity = resource.resourceType === 'single' ? overlapping.length > 0 ? 0 : 1 : Math.max(0, maxCapacity - usedCapacity);
-  if (overlapping.length > 0 && resource.resourceType === 'single') {
-    reasonCodes.push('remote_event_overlap');
-    conflicts.push(...overlapping.map(event => ({
-      type: 'remote_event_overlap',
-      message: '资源时间被已有预约占用',
-      event,
-      resourceId: resource.id,
-      productId: interval.productId
-    })));
-  }
-  if (resource.resourceType !== 'single' && remainingCapacity < requiredCapacity) {
-    reasonCodes.push('capacity_full');
-    conflicts.push({
-      type: 'capacity_full',
-      message: '资源剩余容量不足',
-      resourceId: resource.id,
-      productId: interval.productId
+  if (!value || typeof value !== 'object') return value;
+  return Object.keys(value).reduce((result, key) => {
+    result[key] = cloneSnapshotMetadataValue(value[key]);
+    return result;
+  }, {});
+}
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  Object.getOwnPropertyNames(value).forEach(key => {
+    // `raw` is an explicit escape hatch to the backend/catalog record. It is not owned by the
+    // projection and must not freeze mutable ProductList / Order data shared elsewhere.
+    if (key === 'raw') return;
+    const child = value[key];
+    if (child && (typeof child === 'object' || typeof child === 'function')) {
+      deepFreeze(child);
+    }
+  });
+  return value;
+}
+function createAvailabilityProjection(input) {
+  const coverage = normalizeCoverage(input);
+  const fixedOffsetMinutes = (0, _localClock.captureRuntimeOffsetMinutes)();
+  const runtimeNow = (0, _localClock.localDateToScalar)(new Date());
+  const products = normalizeProducts(input.products || []);
+  const resources = normalizeResources(input.resources || []);
+  const resourceOccupancies = uniqByOccupancy((input.resourceOccupancies || []).map(occupancy => normalizeOccupancy(occupancy, coverage.absolute, input.timezone, fixedOffsetMinutes)).filter(occupancy => Boolean(occupancy)));
+  const preparedAt = normalizeProjectionInstant(input.preparedAt, runtimeNow, input.timezone, fixedOffsetMinutes);
+  const now = normalizeProjectionInstant(input.now, runtimeNow, input.timezone, fixedOffsetMinutes);
+  const durationCandidateAnchorAt = normalizeProjectionInstant(input.durationCandidateAnchorAt || now, runtimeNow, input.timezone, fixedOffsetMinutes);
+  const businessHours = {
+    startTime: input.businessHours?.startTime || DEFAULT_BUSINESS_HOURS.startTime,
+    endTime: input.businessHours?.endTime || DEFAULT_BUSINESS_HOURS.endTime
+  };
+  const operatingHours = normalizeOperatingHours({
+    input: input.operatingHours,
+    businessHours,
+    coverage: coverage.absolute,
+    dateRange: coverage.dateRange,
+    timezoneName: input.timezone,
+    fixedOffsetMinutes,
+    fallbackSource: input.businessHours ? 'prepare_business_hours' : 'default_business_hours'
+  });
+  const meta = {
+    snapshotId: input.snapshotId || `availability-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    preparedAt,
+    timezone: input.timezone,
+    orderRevision: input.orderRevision,
+    mode: input.mode || 'appointment',
+    coverage: {
+      ...coverage.dateRange,
+      ...makeCoverageAbsolute(coverage.dateRange, input.timezone, fixedOffsetMinutes)
+    },
+    defaults: {
+      slotStepMinutes: Math.max(1, Number(input.slotStepMinutes || DEFAULT_SLOT_STEP_MINUTES) || DEFAULT_SLOT_STEP_MINUTES),
+      businessHours: {
+        ...businessHours
+      },
+      operatingHours
+    },
+    now,
+    durationCandidateAnchorAt,
+    anchors: input.anchors ? cloneSnapshotMetadataValue(input.anchors) : undefined,
+    prepareParams: input.prepareParams ? cloneSnapshotMetadataValue(input.prepareParams) : undefined
+  };
+  const projectionBase = {
+    meta,
+    products,
+    resources,
+    resourceOccupancies
+  };
+  return deepFreeze({
+    ...projectionBase,
+    cells: buildCells(projectionBase)
+  });
+}
+function uniqByOccupancy(occupancies) {
+  const map = new Map();
+  occupancies.forEach(occupancy => {
+    map.set(dedupeOccupancyRefKey(occupancy), occupancy);
+  });
+  return Array.from(map.values());
+}
+function resolveProjectionDateRange(projection, requestDateRange) {
+  const startDate = requestDateRange?.startDate || projection.meta.coverage.startDate;
+  const endDate = requestDateRange?.endDate || projection.meta.coverage.endDate;
+  const isCanonicalDate = value => {
+    try {
+      return (0, _localClock.formatLocalDate)((0, _localClock.parseLocalDate)(value)) === value;
+    } catch (_error) {
+      return false;
+    }
+  };
+  if (!isCanonicalDate(startDate) || !isCanonicalDate(endDate) || endDate < startDate) {
+    throw availabilityError('INVALID_DATE_RANGE', '查询日期范围必须是有效的 YYYY-MM-DD，且结束日期不能早于开始日期', {
+      requested: requestDateRange
     });
   }
-  let status = 'available';
-  if (reasonCodes.includes('past')) status = 'past';else if (reasonCodes.includes('outside_resource_time')) status = 'unavailable';else if (reasonCodes.includes('remote_event_overlap') || reasonCodes.includes('capacity_full')) {
-    status = 'full';
-  } else if (remainingCapacity < maxCapacity) {
-    status = 'limited';
+  if (startDate < projection.meta.coverage.startDate || endDate > projection.meta.coverage.endDate) {
+    throw availabilityError('OUT_OF_PROJECTION_COVERAGE', '查询范围超出 projection.coverage', {
+      requested: requestDateRange,
+      coverage: projection.meta.coverage
+    });
   }
   return {
-    key: `${interval.productId}:${resource.id}:${interval.start_at}:${interval.end_at}`,
-    productId: interval.productId,
-    resourceId: resource.id,
-    date: interval.date,
-    start_at: interval.start_at,
-    end_at: interval.end_at,
-    startTime: timeOf(interval.start_at),
-    endTime: timeOf(interval.end_at),
-    durationMinutes: interval.durationMinutes,
-    cellType: status === 'available' || status === 'limited' ? 'fixed_interval' : 'unavailable',
-    status,
-    remainingCapacity,
-    maxCapacity,
-    reasonCodes,
-    conflicts
+    startDate,
+    endDate
   };
 }
-function aggregateStatus(cells) {
-  if (!cells.length) return 'unavailable';
-  if (cells.some(cell => cell.status === 'available')) return 'available';
-  if (cells.some(cell => cell.status === 'limited')) return 'limited';
-  if (cells.some(cell => cell.status === 'past')) return 'past';
-  if (cells.some(cell => cell.status === 'full')) return 'full';
-  if (cells.some(cell => cell.status === 'conflict')) return 'conflict';
-  return 'unavailable';
+function buildOperatingRanges(projection, dateRange) {
+  const coverage = {
+    start: toDateStart(dateRange.startDate, projection.meta.timezone),
+    end: toDateEnd(nextDate(dateRange.endDate), projection.meta.timezone)
+  };
+  return mergeRanges(projection.meta.defaults.operatingHours.windows.map(window => normalizeAbsoluteRange(window, projection.meta.timezone)).filter(window => Boolean(window)).map(window => clipRange(window, coverage)).filter(window => Boolean(window)));
 }
-function uniqueReasonCodes(cells) {
-  return Array.from(new Set(cells.flatMap(cell => cell.reasonCodes || [])));
+function buildResourceWindowIndex(projection) {
+  const coverage = {
+    start: toDateTime(projection.meta.coverage.startAt, projection.meta.timezone),
+    end: toDateTime(projection.meta.coverage.endAt, projection.meta.timezone)
+  };
+  return new Map(projection.resources.map(resource => [String(resource.id), normalizeResourceWindow(resource, coverage, projection.meta.timezone)]));
 }
-function buildProductOptions(products, cells, query) {
-  const queryProducts = getQueryProducts(products, query);
-  return queryProducts.map(product => {
-    const productCells = cells.filter(cell => sameId(cell.productId, product.id));
-    const status = product.kind === 'normal' ? 'available' : aggregateStatus(productCells);
-    return {
-      productId: product.id,
-      title: resolveProductTitle(product),
-      status,
-      reasonCodes: uniqueReasonCodes(productCells)
+function buildGroupWorkingRanges(params) {
+  const {
+    projection,
+    requirementGroup,
+    dateRange,
+    resourceIds,
+    partySize
+  } = params;
+  const guardEndDate = nextDate(dateRange.endDate, projection.meta.timezone);
+  const coverage = {
+    start: toDateStart(dateRange.startDate, projection.meta.timezone),
+    end: toDateEnd(guardEndDate, projection.meta.timezone)
+  };
+  const filteredResourceIdSet = resourceIds?.length ? new Set(resourceIds.map(String)) : null;
+  const resourceWindows = projection.resources.filter(resource => matchesRequirementGroup(requirementGroup, resource, params.product, partySize)).filter(resource => !filteredResourceIdSet || filteredResourceIdSet.has(String(resource.id))).map(resource => {
+    const windows = params.resourceWindowIndex?.get(String(resource.id)) || normalizeResourceWindow(resource, coverage, projection.meta.timezone);
+    return windows.map(window => clipRange(window, coverage)).filter(window => Boolean(window));
+  });
+  const requiredConcurrentResources = Math.max(requirementGroup.required === false ? 0 : 1, Number(requirementGroup.min ?? (requirementGroup.required === false ? 0 : 1)) || 0);
+  if (requiredConcurrentResources <= 1) {
+    return mergeRanges(resourceWindows.flatMap(windows => windows));
+  }
+  const boundaries = new Set();
+  resourceWindows.forEach(windows => {
+    windows.forEach(window => {
+      boundaries.add(window.start);
+      boundaries.add(window.end);
+    });
+  });
+  const sortedBoundaries = Array.from(boundaries.values()).sort((left, right) => left - right);
+  const satisfiedRanges = [];
+  for (let index = 0; index < sortedBoundaries.length - 1; index += 1) {
+    const start = sortedBoundaries[index];
+    const end = sortedBoundaries[index + 1];
+    if (end <= start) continue;
+    const segment = {
+      start,
+      end
     };
+    const activeResources = resourceWindows.reduce((count, windows) => windows.some(window => contains(window, segment)) ? count + 1 : count, 0);
+    if (activeResources >= requiredConcurrentResources) {
+      satisfiedRanges.push(segment);
+    }
+  }
+  return mergeRanges(satisfiedRanges);
+}
+function materializeScheduleRules(rules, dateRange, timezoneName, fixedOffsetMinutes) {
+  const dates = enumerateDates(dateRange.startDate, dateRange.endDate);
+  const seen = new Map();
+  rules.forEach(rule => {
+    dates.forEach(date => {
+      if (!matchesScheduleRuleDate(rule, date, timezoneName)) return;
+      const start = toDateTimeInDate(date, rule.startTime, timezoneName);
+      let end = toDateTimeInDate(date, rule.endTime, timezoneName);
+      if (end <= start) end = toDateTimeInDate(nextDate(date, timezoneName), rule.endTime, timezoneName);
+      const key = `${date}:${start}:${end}`;
+      if (!seen.has(key)) {
+        seen.set(key, {
+          key,
+          productId: '',
+          source: 'session_schedule',
+          startAt: formatDateTime(start, timezoneName, fixedOffsetMinutes),
+          endAt: formatDateTime(end, timezoneName, fixedOffsetMinutes),
+          bookingStartAt: formatDateTime(start, timezoneName, fixedOffsetMinutes),
+          bookingEndAt: formatDateTime(end, timezoneName, fixedOffsetMinutes),
+          date: formatDate(start, timezoneName),
+          startTime: formatTime(start, timezoneName),
+          endTime: formatTime(end, timezoneName),
+          timezone: timezoneName,
+          scheduleRefs: []
+        });
+      }
+      const current = seen.get(key);
+      const scheduleRef = {
+        ...(rule.scheduleRef || {}),
+        ruleId: rule.id
+      };
+      current.scheduleRefs = mergeScheduleRefs(current.scheduleRefs, [scheduleRef]);
+      if (!current.primaryScheduleRef) current.primaryScheduleRef = scheduleRef;
+    });
   });
+  return Array.from(seen.values());
 }
-function buildResourceOptions(resources, cells, query) {
-  const queryResources = getQueryResources(resources, query);
-  return queryResources.map(resource => {
-    const resourceCells = cells.filter(cell => cell.resourceId !== undefined && sameId(cell.resourceId, resource.id));
-    const bestCell = resourceCells.find(cell => cell.status === 'available') || resourceCells.find(cell => cell.status === 'limited') || resourceCells[0];
-    return {
-      resourceId: resource.id,
-      resourceName: resource.name,
-      resourceFormId: resource.formId,
-      resourceType: resource.resourceType,
-      status: resourceCells.length ? aggregateStatus(resourceCells) : 'unavailable',
-      remainingCapacity: bestCell?.remainingCapacity,
-      maxCapacity: bestCell?.maxCapacity || resource.capacity,
-      reasonCodes: uniqueReasonCodes(resourceCells)
-    };
+function matchesScheduleRuleDate(rule, date, _timezoneName) {
+  if (rule.includeDates?.includes(date)) return true;
+  if (rule.excludeDates?.includes(date)) return false;
+  if (rule.startDate && date < rule.startDate) return false;
+  if (rule.endDate && date > rule.endDate) return false;
+  if (rule.mode === 'designation') {
+    if (rule.dates?.includes(date)) return true;
+    return false;
+  }
+  if (rule.mode === 'weekly') {
+    if (!rule.weekdays?.length) return true;
+    const freq = Math.max(1, Number(rule.frequency || 1) || 1);
+    if (!rule.weekdays.includes((0, _localClock.weekdayFromLocalDate)(date))) return false;
+    if (!rule.startDate) return true;
+    const targetWeekStart = (0, _localClock.dateOrdinalFromLocalDate)(date) - (0, _localClock.weekdayFromLocalDate)(date);
+    const ruleWeekStart = (0, _localClock.dateOrdinalFromLocalDate)(rule.startDate) - (0, _localClock.weekdayFromLocalDate)(rule.startDate);
+    return Math.floor((targetWeekStart - ruleWeekStart) / 7) % freq === 0;
+  }
+  if (rule.mode === 'daily' && rule.startDate) {
+    const freq = Math.max(1, Number(rule.frequency || 1) || 1);
+    return ((0, _localClock.dateOrdinalFromLocalDate)(date) - (0, _localClock.dateOrdinalFromLocalDate)(rule.startDate)) % freq === 0;
+  }
+  return true;
+}
+function mergeScheduleRefs(base, next) {
+  const map = new Map();
+  [...base, ...next].forEach(ref => {
+    const key = [ref.scheduleId ?? '', ref.timeSlotId ?? '', ref.ruleId ?? '', ref.source ?? '', ref.label ?? ''].join(':');
+    map.set(key, ref);
+  });
+  return Array.from(map.values());
+}
+function buildProductIndex(projection) {
+  return new Map(projection.products.map(product => [String(product.id), product]));
+}
+function buildGroupResourceIndex(params) {
+  const resourceIdSet = params.resourceIds?.length ? new Set(params.resourceIds.map(String)) : null;
+  const index = new Map();
+  params.projection.products.forEach(product => {
+    (product.requirementGroups || []).forEach(requirementGroup => {
+      const key = [String(product.id), requirementGroup.id].join(':');
+      index.set(key, params.projection.resources.filter(resource => matchesRequirementGroup(requirementGroup, resource, product, params.partySize)).filter(resource => !resourceIdSet || resourceIdSet.has(String(resource.id))));
+    });
   });
+  return index;
 }
-function buildDateSummary(cells, query) {
-  const dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : Array.from(new Set(cells.map(cell => cell.date).filter(Boolean)));
-  return dates.map(date => {
-    const dateCells = cells.filter(cell => cell.date === date);
-    const availableCount = dateCells.filter(cell => cell.status === 'available' || cell.status === 'limited').length;
+function getSessionRangesForProduct(projection, product, dateRange) {
+  const fixedOffsetMinutes = (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const ranges = (product.sessionRanges || []).map(range => {
+    const normalized = normalizeAbsoluteRange(range, projection.meta.timezone);
+    if (!normalized) return null;
+    const startDate = formatDate(normalized.start, projection.meta.timezone);
+    if (startDate < dateRange.startDate || startDate > dateRange.endDate) {
+      return null;
+    }
     return {
-      date,
-      status: dateCells.length ? aggregateStatus(dateCells) : 'unavailable',
-      availableCount,
-      totalCount: dateCells.length
+      key: `${String(product.id)}:${normalized.start}:${normalized.end}`,
+      productId: product.id,
+      source: 'session_schedule',
+      startAt: formatDateTime(normalized.start, projection.meta.timezone, fixedOffsetMinutes),
+      endAt: formatDateTime(normalized.end, projection.meta.timezone, fixedOffsetMinutes),
+      bookingStartAt: formatDateTime(normalized.start, projection.meta.timezone, fixedOffsetMinutes),
+      bookingEndAt: formatDateTime(normalized.end, projection.meta.timezone, fixedOffsetMinutes),
+      date: formatDate(normalized.start, projection.meta.timezone),
+      startTime: formatTime(normalized.start, projection.meta.timezone),
+      endTime: formatTime(normalized.end, projection.meta.timezone),
+      timezone: projection.meta.timezone,
+      scheduleRefs: range.scheduleRefs || [],
+      primaryScheduleRef: range.scheduleRefs?.[0]
     };
+  }).filter(Boolean);
+  const ruleRanges = materializeScheduleRules(product.sessionRules || [], dateRange, projection.meta.timezone, fixedOffsetMinutes);
+  return dedupeProductRanges([...ranges, ...ruleRanges.map(range => ({
+    ...range,
+    key: `${String(product.id)}:${range.startAt}:${range.endAt}`,
+    productId: product.id,
+    timezone: projection.meta.timezone
+  }))]);
+}
+function dedupeProductRanges(ranges) {
+  const map = new Map();
+  ranges.forEach(range => {
+    const key = getProductTimeRangeIdentity(range);
+    if (!map.has(key)) {
+      map.set(key, {
+        ...range,
+        key
+      });
+      return;
+    }
+    const existing = map.get(key);
+    existing.scheduleRefs = mergeScheduleRefs(existing.scheduleRefs, range.scheduleRefs || []);
+    if (!existing.primaryScheduleRef) existing.primaryScheduleRef = range.primaryScheduleRef;
   });
+  return Array.from(map.values()).sort((left, right) => left.startAt.localeCompare(right.startAt));
 }
-function buildTimeLabels(date, context, query) {
-  if (!date) return [];
-  const slotMinutes = query.slotDurationMinutes || context.slotDurationMinutes;
-  const labels = [];
-  let cursor = toDateTime(date, context.businessStartTime);
-  let end = toDateTime(date, context.businessEndTime);
-  if (!end.isAfter(cursor)) end = end.add(1, 'day');
-  while (cursor.isBefore(end)) {
-    labels.push(cursor.format('HH:mm'));
-    cursor = cursor.add(slotMinutes, 'minute');
-  }
-  return labels;
+function createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes) {
+  const bookingEnd = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+  return createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes);
 }
-function buildGridSlotInterval(product, date, label, context, query) {
-  const slotMinutes = product.kind === 'duration' ? Math.max(1, Number(product.durationMinutes || query.slotDurationMinutes || context.slotDurationMinutes)) : query.slotDurationMinutes || context.slotDurationMinutes;
-  const start = toDateTime(date, label);
-  const end = start.add(slotMinutes, 'minute');
+function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes) {
   return {
-    id: `${product.id}:${date}:${label}`,
+    key: `${String(product.id)}:${start}:${bookingEnd}`,
     productId: product.id,
-    source: product.kind === 'session' ? 'session' : product.kind === 'venue_slot' ? 'venue_slot' : 'duration',
-    date,
-    start_at: start.toISOString(),
-    end_at: end.toISOString(),
-    durationMinutes: slotMinutes,
-    quantity: Math.max(1, Number(product.quantity || 1)),
-    capacityRequired: Math.max(1, Number(query.pax || product.capacityRequired || 1)),
-    resourceRequirements: product.resourceRequirements || []
-  };
-}
-function buildTimeGrid(context, query, cells) {
-  const date = query.date || query.dateRange?.start;
-  const products = getQueryProducts(context.products, query).filter(product => product.kind !== 'normal');
-  const resources = getQueryResources(context.resources, query);
-  const timeLabels = buildTimeLabels(date, context, query);
-  if (!date || !products.length || !resources.length) {
-    return {
-      date,
-      timeLabels,
-      resources: []
-    };
-  }
-  const rows = resources.map(resource => {
-    const slots = timeLabels.map(label => {
-      const product = products[0];
-      const interval = buildGridSlotInterval(product, date, label, context, query);
-      const start = (0, _dayjs.default)(interval.start_at);
-      const end = (0, _dayjs.default)(interval.end_at);
-      const cell = cells.find(item => sameId(item.productId, product.id) && sameId(item.resourceId, resource.id) && item.date === date && (item.status === 'available' || item.status === 'limited') && containsRange((0, _dayjs.default)(item.start_at), (0, _dayjs.default)(item.end_at), start, end));
+    source: 'duration_window',
+    startAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    bookingStartAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    date: formatDate(start, projection.meta.timezone),
+    startTime: formatTime(start, projection.meta.timezone),
+    endTime: formatTime(bookingEnd, projection.meta.timezone),
+    timezone: projection.meta.timezone,
+    scheduleRefs: []
+  };
+}
+function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
+  const normalizedPartySize = normalizePartySize(request.partySize);
+  const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const slotStepMinutes = projection.meta.defaults.slotStepMinutes;
+  const fixedOffsetMinutes = (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)();
+  const resourceWindowIndex = buildResourceWindowIndex(projection);
+  const filteredProductIdSet = request.productIds?.length ? new Set(request.productIds.map(String)) : null;
+  return projection.products.filter(product => !filteredProductIdSet || filteredProductIdSet.has(String(product.id))).map(product => {
+    if (product.kind === 'normal') {
       return {
-        startTime: label,
-        endTime: (0, _dayjs.default)(interval.end_at).format('HH:mm'),
-        status: cell?.status || 'unavailable',
-        resourceId: resource.id,
         productId: product.id,
-        remainingCapacity: cell?.remainingCapacity,
-        maxCapacity: cell?.maxCapacity || resource.capacity,
-        reasonCodes: cell?.reasonCodes || ['outside_available_range']
+        title: product.title,
+        kind: product.kind,
+        slotStepMinutes,
+        ranges: []
       };
+    }
+    if (product.kind === 'session' || product.kind === 'venue_slot') {
+      return {
+        productId: product.id,
+        title: product.title,
+        kind: product.kind,
+        slotStepMinutes,
+        ranges: getSessionRangesForProduct(projection, product, dateRange)
+      };
+    }
+    const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false);
+    const operatingRanges = buildOperatingRanges(projection, dateRange);
+    const resourceRanges = requiredGroups.length ? requiredGroups.map(group => buildGroupWorkingRanges({
+      projection,
+      product,
+      requirementGroup: group,
+      dateRange,
+      resourceIds: request.resourceIds,
+      partySize: normalizedPartySize,
+      resourceWindowIndex
+    })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
+    const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
+    const durationMinutes = resolveRequestedDurationMinutes(product, request);
+    const flexibleStartAt = (() => {
+      if (!product.isFlexibleDuration) return undefined;
+      const evaluatedAt = toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt, projection.meta.timezone);
+      if (!Number.isFinite(evaluatedAt)) {
+        throw availabilityError('INVALID_TARGET_FILTER', 'runtimeOptions.evaluatedAt 必须是有效时间', {
+          evaluatedAt: runtimeOptions.evaluatedAt
+        });
+      }
+      return floorToMinute(evaluatedAt);
+    })();
+    const durationAnchor = ceilToTenMinutes(toDateTime(projection.meta.durationCandidateAnchorAt, projection.meta.timezone), projection.meta.timezone);
+    const requestedStartTimes = resolveRequestedDurationStartTimes(product, request);
+    const ranges = [];
+    baseRanges.forEach(range => {
+      if (product.isFlexibleDuration && flexibleStartAt !== undefined) {
+        const start = Math.max(range.start, flexibleStartAt);
+        if (start >= range.end) return;
+        const bookingDate = formatDate(start);
+        if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
+          ranges.push(createDurationTimeRangeWithEnd(product, start, range.end, projection, fixedOffsetMinutes));
+        }
+        return;
+      }
+      if (range.end <= durationAnchor) return;
+      let cursor = range.start;
+      if (cursor < durationAnchor) {
+        cursor = durationAnchor;
+      }
+      while (true) {
+        const bookingEnd = addMinutesZoned(cursor, durationMinutes, projection.meta.timezone);
+        if (bookingEnd > range.end) break;
+        const bookingDate = formatDate(cursor);
+        if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
+          ranges.push(createDurationTimeRange(product, cursor, durationMinutes, projection, fixedOffsetMinutes));
+        }
+        cursor = addMinutesZoned(cursor, slotStepMinutes, projection.meta.timezone);
+      }
     });
+    if (dateRange.startDate === dateRange.endDate && requestedStartTimes.length > 0) {
+      requestedStartTimes.forEach(startTime => {
+        const start = toDateTimeInDate(dateRange.startDate, startTime, projection.meta.timezone);
+        if (!Number.isFinite(start)) return;
+        const end = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+        const startsInOperatingRange = operatingRanges.some(range => range.start <= start && start < range.end);
+        if (!startsInOperatingRange && !request.allowOutsideOperatingHoursForRequestedStartTimes) {
+          return;
+        }
+        ranges.push(createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes));
+      });
+    }
     return {
-      resourceId: resource.id,
-      resourceName: resource.name,
-      resourceFormId: resource.formId,
-      slots
+      productId: product.id,
+      title: product.title,
+      kind: product.kind,
+      slotStepMinutes,
+      ranges: dedupeProductRanges(ranges)
     };
   });
+}
+function aggregateMatchedCells(productId, requirementGroupId, resourceId, candidateRange, indexedCells) {
+  const candidateStartMs = candidateRange.start;
+  const candidateEndMs = candidateRange.end;
+  let left = 0;
+  let right = indexedCells.length;
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+    if (indexedCells[middle].range.endMs <= candidateStartMs) {
+      left = middle + 1;
+    } else {
+      right = middle;
+    }
+  }
+  const overlapped = [];
+  for (let index = Math.max(0, left - 1); index < indexedCells.length; index += 1) {
+    const {
+      cell,
+      range
+    } = indexedCells[index];
+    if (range.startMs >= candidateEndMs) break;
+    if (range.endMs <= candidateStartMs) continue;
+    const clipped = clipRange(range, candidateRange);
+    if (clipped) overlapped.push({
+      cell,
+      range: clipped
+    });
+  }
+  if (!overlapped.length) return undefined;
+  let cursor = candidateRange.start;
+  for (const item of overlapped) {
+    if (item.range.start > cursor) return undefined;
+    if (item.range.end > cursor) {
+      cursor = item.range.end;
+    }
+    if (cursor >= candidateRange.end) break;
+  }
+  if (cursor < candidateRange.end) return undefined;
+  const cells = overlapped.map(item => item.cell);
+  const statuses = cells.map(cell => cell.status);
+  const nonPastStatuses = statuses.filter(status => status !== 'past');
+  const aggregatedStatus = (() => {
+    if (nonPastStatuses.some(status => status === 'unavailable')) return 'unavailable';
+    if (nonPastStatuses.some(status => status === 'full')) return 'full';
+    if (nonPastStatuses.some(status => status === 'limited')) return 'limited';
+    if (nonPastStatuses.every(status => status === 'available')) return 'available';
+    if (statuses.every(status => status === 'past')) return 'past';
+    return 'available';
+  })();
+  const capacityCells = cells.filter(cell => cell.remainingCapacity !== undefined || cell.maxCapacity !== undefined);
+  const reasonCodes = Array.from(new Set(cells.flatMap(cell => cell.reasonCodes)));
+  const occupancyRefs = Array.from(new Map(cells.flatMap(cell => cell.occupancyRefs || []).map(ref => [[ref.id ?? '', ref.resourceId ?? '', ref.serverEventId ?? '', ref.bookingUid ?? '', ref.productUid ?? '', ref.scheduleEventId ?? '', ref.source ?? ''].join(':'), ref])).values());
+  const firstCell = cells[0];
   return {
-    date,
-    timeLabels,
-    resources: rows
+    ...firstCell,
+    key: buildCellKey({
+      productId,
+      groupId: requirementGroupId,
+      resourceId,
+      start: candidateRange.start,
+      end: candidateRange.end
+    }),
+    startAt: formatDateTime(candidateRange.start, firstCell.timezone, (0, _localClock.extractFixedOffsetMinutes)(firstCell.startAt) ?? (0, _localClock.captureRuntimeOffsetMinutes)()),
+    endAt: formatDateTime(candidateRange.end, firstCell.timezone, (0, _localClock.extractFixedOffsetMinutes)(firstCell.startAt) ?? (0, _localClock.captureRuntimeOffsetMinutes)()),
+    date: formatDate(candidateRange.start, firstCell.timezone),
+    startTime: formatTime(candidateRange.start, firstCell.timezone),
+    endTime: formatTime(candidateRange.end, firstCell.timezone),
+    status: aggregatedStatus,
+    remainingCapacity: capacityCells.length ? Math.min(...capacityCells.map(cell => cell.remainingCapacity ?? Number.MAX_SAFE_INTEGER)) : undefined,
+    maxCapacity: capacityCells.length ? Math.min(...capacityCells.map(cell => cell.maxCapacity ?? Number.MAX_SAFE_INTEGER)) : undefined,
+    reasonCodes,
+    occupancyRefs
   };
 }
-function queryPlannerAvailability(contextInput, query = {}) {
-  const context = normalizePlannerContext(contextInput);
-  const intervals = buildDemandIntervals(context.products, query, context);
-  const resources = getQueryResources(context.resources, query);
-  const eventsByResource = collectEventsByResource(resources, context.externalEvents);
-  const cells = [];
-  for (const interval of intervals) {
-    const candidateResources = resources.filter(resource => {
-      const requirements = interval.resourceRequirements || [];
-      if (!requirements.length) return true;
-      return requirements.some(requirement => matchesResourceRequirement(resource, requirement));
-    });
-    if (!candidateResources.length) {
-      cells.push({
-        key: `${interval.productId}:missing-resource:${interval.start_at}`,
-        productId: interval.productId,
-        date: interval.date,
-        start_at: interval.start_at,
-        end_at: interval.end_at,
-        startTime: timeOf(interval.start_at),
-        endTime: timeOf(interval.end_at),
-        durationMinutes: interval.durationMinutes,
-        cellType: 'unavailable',
-        status: 'unavailable',
-        reasonCodes: ['missing_resource'],
-        conflicts: [{
-          type: 'missing_resource',
-          message: '没有匹配商品需求的资源',
-          productId: interval.productId
-        }]
-      });
-      continue;
+function aggregateMatchedCellSummary(candidateRange, indexedCells) {
+  const candidateStartMs = candidateRange.startMs;
+  const candidateEndMs = candidateRange.endMs;
+  let left = 0;
+  let right = indexedCells.length;
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+    if (indexedCells[middle].range.endMs <= candidateStartMs) {
+      left = middle + 1;
+    } else {
+      right = middle;
     }
-    candidateResources.forEach(resource => {
-      if (interval.source === 'duration' && !query.startTime) {
-        cells.push(...buildAvailabilityCellsForResource({
-          resource,
-          interval,
-          events: eventsByResource.get(String(resource.id)) || []
-        }));
-        return;
-      }
-      cells.push(evaluateResourceForInterval({
-        resource,
-        interval,
-        context
-      }));
-    });
   }
+  const cells = [];
+  let cursorMs = candidateStartMs;
+  for (let index = Math.max(0, left - 1); index < indexedCells.length; index += 1) {
+    const {
+      cell,
+      range
+    } = indexedCells[index];
+    if (range.startMs >= candidateEndMs) break;
+    if (range.endMs <= candidateStartMs) continue;
+    const clippedStartMs = Math.max(range.startMs, candidateStartMs);
+    const clippedEndMs = Math.min(range.endMs, candidateEndMs);
+    if (clippedEndMs <= clippedStartMs) continue;
+    if (clippedStartMs > cursorMs) return undefined;
+    cells.push(cell);
+    if (clippedEndMs > cursorMs) cursorMs = clippedEndMs;
+    if (cursorMs >= candidateEndMs) break;
+  }
+  if (!cells.length || cursorMs < candidateEndMs) return undefined;
+  const statuses = cells.map(cell => cell.status);
+  const nonPastStatuses = statuses.filter(status => status !== 'past');
+  const status = (() => {
+    if (nonPastStatuses.some(cellStatus => cellStatus === 'unavailable')) return 'unavailable';
+    if (nonPastStatuses.some(cellStatus => cellStatus === 'full')) return 'full';
+    if (nonPastStatuses.some(cellStatus => cellStatus === 'limited')) return 'limited';
+    if (nonPastStatuses.every(cellStatus => cellStatus === 'available')) return 'available';
+    if (statuses.every(cellStatus => cellStatus === 'past')) return 'past';
+    return 'available';
+  })();
+  const capacityCells = cells.filter(cell => cell.remainingCapacity !== undefined || cell.maxCapacity !== undefined);
   return {
-    query,
-    demandIntervals: intervals,
-    productOptions: buildProductOptions(context.products, cells, query),
-    resourceOptions: buildResourceOptions(context.resources, cells, query),
-    dateSummary: buildDateSummary(cells, query),
-    timeGrid: buildTimeGrid(context, query, cells),
-    cells
-  };
-}
-function getIntervalRequirements(interval) {
-  return interval.resourceRequirements.length ? interval.resourceRequirements : [{
-    capacityRequired: interval.capacityRequired,
-    required: true
-  }];
-}
-function buildAssignableCandidateGroups(params) {
-  const {
-    interval,
-    cells,
-    resources
-  } = params;
-  const conflicts = [];
-  const groups = getIntervalRequirements(interval).map(requirement => {
-    const candidateCells = cells.filter(cell => {
-      if (!sameId(cell.productId, interval.productId)) return false;
-      if (cell.date !== interval.date) return false;
-      if (cell.resourceId === undefined) return false;
-      if (cell.status !== 'available' && cell.status !== 'limited') return false;
-      const cellStart = (0, _dayjs.default)(cell.start_at);
-      const cellEnd = (0, _dayjs.default)(cell.end_at);
-      const intervalStart = (0, _dayjs.default)(interval.start_at);
-      const intervalEnd = (0, _dayjs.default)(interval.end_at);
-      return containsRange(cellStart, cellEnd, intervalStart, intervalEnd) || interval.source === 'duration';
-    });
-    return candidateCells.flatMap(cell => {
-      const resource = resources.find(item => sameId(item.id, cell.resourceId));
-      if (!resource || !matchesResourceRequirement(resource, requirement)) return [];
-      return [{
-        requirement,
-        resource,
-        cell
-      }];
+    status,
+    remainingCapacity: capacityCells.length ? Math.min(...capacityCells.map(cell => cell.remainingCapacity ?? Number.MAX_SAFE_INTEGER)) : undefined,
+    maxCapacity: capacityCells.length ? Math.min(...capacityCells.map(cell => cell.maxCapacity ?? Number.MAX_SAFE_INTEGER)) : undefined,
+    reasonCodes: Array.from(new Set(cells.flatMap(cell => cell.reasonCodes)))
+  };
+}
+function buildAvailabilityCellIndex(projection) {
+  const index = new Map();
+  projection.cells.forEach(cell => {
+    if (cell.requirementGroupId == null || cell.resourceId == null) return;
+    const key = [String(cell.productId), cell.requirementGroupId, String(cell.resourceId)].join(':');
+    const entries = index.get(key) || [];
+    entries.push({
+      cell,
+      range: toIndexedRange({
+        start: toDateTime(cell.startAt, projection.meta.timezone),
+        end: toDateTime(cell.endAt, projection.meta.timezone)
+      })
     });
+    index.set(key, entries);
   });
-  groups.forEach((group, index) => {
-    if (group.length) return;
-    conflicts.push({
-      type: 'missing_resource',
-      message: '没有匹配商品需求的可用资源',
-      productId: interval.productId,
-      resourceId: interval.resourceRequirements[index]?.resourceIds?.[0]
-    });
+  index.forEach((entries, key) => {
+    index.set(key, entries.sort((left, right) => left.range.startMs - right.range.startMs));
+  });
+  return index;
+}
+function buildEvaluationContext(params) {
+  const evaluatedAt = toDateTime(params.evaluatedAt || params.projection.meta.now, params.projection.meta.timezone);
+  const selectionsByGroupKey = new Map();
+  (params.requirementSelections || []).forEach(selection => {
+    const key = selection.requirementGroupId || String(selection.formId ?? '');
+    selectionsByGroupKey.set(key, selection);
   });
   return {
-    groups,
-    conflicts
+    evaluatedAt,
+    evaluatedAtMs: evaluatedAt,
+    resourceIdSet: params.resourceIds?.length ? new Set(params.resourceIds.map(String)) : null,
+    selectionsByGroupKey
   };
 }
-function combineCandidateGroups(groups) {
-  if (!groups.length || groups.some(group => group.length === 0)) return [];
-  return groups.reduce((combinations, group) => combinations.flatMap(combination => group.map(candidate => [...combination, candidate])), [[]]);
+function summarizeStatuses(statuses) {
+  if (!statuses.length) return 'unavailable';
+  if (statuses.every(status => status === 'past')) return 'past';
+  if (statuses.some(status => status === 'unavailable')) return 'unavailable';
+  if (statuses.some(status => status === 'full')) return 'full';
+  if (statuses.some(status => status === 'limited')) return 'limited';
+  if (statuses.every(status => status === 'available')) return 'available';
+  if (statuses.some(status => status === 'past')) return 'past';
+  return statuses[0];
 }
-function buildSlotFromCandidates(params) {
-  const {
-    interval,
-    candidates,
-    start,
-    end
-  } = params;
-  if (!end.isAfter(start)) return null;
-  const status = candidates.some(candidate => candidate.cell.status === 'limited') ? 'limited' : 'available';
-  const assignments = candidates.map(candidate => ({
-    productId: interval.productId,
-    resourceId: candidate.resource.id,
-    start_at: start.toISOString(),
-    end_at: end.toISOString(),
-    capacityRequired: Math.max(1, Number(candidate.requirement.capacityRequired || interval.capacityRequired || 1))
-  }));
+function createStatusAggregate() {
+  return {
+    count: 0,
+    hasAvailable: false,
+    hasLimited: false,
+    hasFull: false,
+    allPast: true
+  };
+}
+function pushStatusAggregate(aggregate, status) {
+  aggregate.count += 1;
+  if (status !== 'past') aggregate.allPast = false;
+  if (status === 'available') aggregate.hasAvailable = true;
+  if (status === 'limited') aggregate.hasLimited = true;
+  if (status === 'full') aggregate.hasFull = true;
+}
+function summarizeStatusAggregate(aggregate) {
+  if (aggregate.count === 0) return 'unavailable';
+  if (aggregate.hasAvailable) return 'available';
+  if (aggregate.hasLimited) return 'limited';
+  if (aggregate.hasFull) return 'full';
+  if (aggregate.allPast) return 'past';
+  return 'unavailable';
+}
+function evaluateMatchedResourceSummary(params) {
+  const isPast = params.candidateRange.endMs <= params.evaluationContext.evaluatedAtMs;
+  if (!params.matchedCell) {
+    return {
+      status: isPast ? 'past' : 'unavailable',
+      maxPartySize: 0,
+      remainingCapacity: 0,
+      maxCapacity: 0,
+      reasonCodes: isPast ? ['past'] : ['outside_resource_window']
+    };
+  }
+  const remainingCapacity = Math.max(0, params.matchedCell.remainingCapacity || 0);
+  const maxCapacity = Math.max(0, params.matchedCell.maxCapacity ?? params.resourceCapacity ?? 0);
+  const maxPartySize = isPast ? 0 : remainingCapacity;
+  const status = (() => {
+    if (isPast) return 'past';
+    if (params.matchedCell.status === 'unavailable') return 'unavailable';
+    if (remainingCapacity < params.requiredCapacity) return 'full';
+    if (remainingCapacity < maxCapacity) return 'limited';
+    return 'available';
+  })();
   return {
-    key: [interval.productId, start.toISOString(), end.toISOString(), ...candidates.map(candidate => candidate.resource.id)].join(':'),
-    productId: interval.productId,
-    date: interval.date,
-    start_at: start.toISOString(),
-    end_at: end.toISOString(),
-    startTime: start.format('HH:mm'),
-    endTime: end.format('HH:mm'),
-    durationMinutes: Math.max(1, end.diff(start, 'minute')),
     status,
-    resources: candidates.map(candidate => ({
-      resourceId: candidate.resource.id,
-      resourceName: candidate.resource.name,
-      resourceFormId: candidate.resource.formId,
-      resourceType: candidate.resource.resourceType,
-      capacityRequired: Math.max(1, Number(candidate.requirement.capacityRequired || interval.capacityRequired || 1)),
-      remainingCapacity: candidate.cell.remainingCapacity,
-      maxCapacity: candidate.cell.maxCapacity
-    })),
-    assignments,
-    conflicts: []
+    remainingCapacity,
+    maxCapacity,
+    maxPartySize,
+    reasonCodes: isPast ? Array.from(new Set([...(params.matchedCell.reasonCodes || []), 'past'])) : params.matchedCell.reasonCodes
   };
 }
-function buildSlotsForInterval(params) {
+function evaluateRequirementGroupSummary(params) {
   const {
-    interval,
-    candidates,
-    query,
-    context
+    projection,
+    product,
+    requirementGroup,
+    candidateRange,
+    requestedPartySize,
+    evaluationContext
   } = params;
-  const start = candidates.reduce((current, candidate) => maxDayjs(current, (0, _dayjs.default)(candidate.cell.start_at)), (0, _dayjs.default)(interval.start_at));
-  const end = candidates.reduce((current, candidate) => minDayjs(current, (0, _dayjs.default)(candidate.cell.end_at)), (0, _dayjs.default)(interval.end_at));
-  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
-  if (interval.source !== 'duration' || query.startTime) {
-    const fixedStart = (0, _dayjs.default)(interval.start_at);
-    const fixedEnd = (0, _dayjs.default)(interval.end_at);
-    if (containsRange(start, end, fixedStart, fixedEnd) || candidates.every(candidate => candidate.cell.cellType === 'fixed_interval')) {
-      const slot = buildSlotFromCandidates({
-        interval,
-        candidates,
-        start: fixedStart,
-        end: fixedEnd
-      });
-      return slot ? [slot] : [];
-    }
-    return [];
-  }
-  const stepMinutes = Math.max(1, Number(query.slotDurationMinutes || context.slotDurationMinutes || 30));
-  const slots = [];
-  let cursor = start;
-  while (!cursor.add(durationMinutes, 'minute').isAfter(end)) {
-    const slotEnd = cursor.add(durationMinutes, 'minute');
-    const slot = buildSlotFromCandidates({
-      interval,
-      candidates,
-      start: cursor,
-      end: slotEnd
+  const required = requirementGroup.required !== false;
+  const minimum = Math.max(required ? 1 : 0, Number(requirementGroup.min ?? (required ? 1 : 0)) || 0);
+  const maximum = Math.max(minimum, Number(requirementGroup.max ?? Math.max(minimum, 1)) || Math.max(minimum, 1));
+  const matchedResources = params.groupResourceIndex?.get([String(product.id), requirementGroup.id].join(':')) || projection.resources.filter(resource => matchesRequirementGroup(requirementGroup, resource, product, requestedPartySize ?? 1)).filter(resource => !evaluationContext.resourceIdSet || evaluationContext.resourceIdSet.has(String(resource.id)));
+  const requiredCapacity = resolveRequiredCapacity(requirementGroup, product, requestedPartySize);
+  const optionStatusAggregate = createStatusAggregate();
+  const reasonCodeSet = new Set();
+  let totalResourceCount = 0;
+  let availableResourceCount = 0;
+  let groupMaxPartySize = 0;
+  let groupRemainingCapacity = 0;
+  let groupMaxCapacity = 0;
+  matchedResources.forEach(resource => {
+    totalResourceCount += 1;
+    const matchedCell = aggregateMatchedCellSummary(candidateRange, params.cellIndex?.get([String(product.id), requirementGroup.id, String(resource.id)].join(':')) || []);
+    const option = evaluateMatchedResourceSummary({
+      matchedCell,
+      resourceCapacity: resource.capacity,
+      requiredCapacity,
+      candidateRange,
+      evaluationContext
     });
-    if (slot) slots.push(slot);
-    cursor = cursor.add(stepMinutes, 'minute');
+    pushStatusAggregate(optionStatusAggregate, option.status);
+    option.reasonCodes.forEach(reasonCode => reasonCodeSet.add(reasonCode));
+    groupRemainingCapacity = Math.max(groupRemainingCapacity, option.remainingCapacity);
+    groupMaxCapacity = Math.max(groupMaxCapacity, option.maxCapacity);
+    if (option.status === 'available' || option.status === 'limited') {
+      availableResourceCount += 1;
+      groupMaxPartySize = Math.max(groupMaxPartySize, option.maxPartySize);
+    }
+  });
+  let status = 'available';
+  if (candidateRange.endMs <= evaluationContext.evaluatedAtMs) {
+    status = 'past';
+  } else if (availableResourceCount < minimum) {
+    status = optionStatusAggregate.hasAvailable || optionStatusAggregate.hasLimited || optionStatusAggregate.hasFull ? 'full' : 'unavailable';
+  } else if (availableResourceCount === totalResourceCount && !optionStatusAggregate.hasLimited && !optionStatusAggregate.hasFull && !optionStatusAggregate.allPast) {
+    status = 'available';
+  } else {
+    status = 'limited';
   }
-  return slots;
+  return {
+    required,
+    min: minimum,
+    max: maximum,
+    status,
+    maxPartySize: groupMaxPartySize,
+    remainingCapacity: groupRemainingCapacity,
+    maxCapacity: groupMaxCapacity,
+    reasonCodes: Array.from(reasonCodeSet)
+  };
 }
-function resolveAssignableSlots(contextInput, query = {}) {
-  const context = normalizePlannerContext(contextInput);
-  const projection = queryPlannerAvailability(context, query);
-  const resources = getQueryResources(context.resources, query);
-  const slotsByKey = new Map();
-  const conflicts = [];
-  projection.demandIntervals.forEach(interval => {
-    const {
-      groups,
-      conflicts: groupConflicts
-    } = buildAssignableCandidateGroups({
-      interval,
-      cells: projection.cells,
-      resources
+function evaluateCandidateSummary(projection, candidate, request) {
+  const product = request.productIndex?.get(String(candidate.productId)) || projection.products.find(item => sameId(item.id, candidate.productId));
+  if (!product) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'candidate.productId 不存在于 projection.products', {
+      candidate
     });
-    conflicts.push(...groupConflicts);
-    combineCandidateGroups(groups).forEach(candidates => {
-      buildSlotsForInterval({
-        interval,
-        candidates,
-        query,
-        context
-      }).forEach(slot => {
-        if (!slotsByKey.has(slot.key)) slotsByKey.set(slot.key, slot);
-      });
+  }
+  const candidateRangeCacheKey = getCandidateRangeCacheKey(candidate);
+  const candidateRange = request.candidateRangeCache?.get(candidateRangeCacheKey) || (() => {
+    const normalized = normalizeAbsoluteRange(getCandidateBookingRange(candidate), projection.meta.timezone);
+    return normalized ? toIndexedRange(normalized) : null;
+  })();
+  if (!candidateRange) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'candidate 时间范围非法', {
+      candidate
     });
+  }
+  if (request.candidateRangeCache && !request.candidateRangeCache.has(candidateRangeCacheKey)) {
+    request.candidateRangeCache.set(candidateRangeCacheKey, candidateRange);
+  }
+  const evaluationContext = request.evaluationContext || buildEvaluationContext({
+    projection,
+    evaluatedAt: request.evaluatedAt,
+    resourceIds: request.resourceIds
   });
-  return {
+  const requestedPartySize = normalizePartySize(request.partySize);
+  const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false).map(requirementGroup => evaluateRequirementGroupSummary({
     projection,
-    slots: Array.from(slotsByKey.values()),
-    conflicts
+    product,
+    requirementGroup,
+    candidateRange,
+    requestedPartySize,
+    evaluationContext,
+    cellIndex: request.cellIndex,
+    groupResourceIndex: request.groupResourceIndex
+  }));
+  const gate = evaluateCandidateTimeGate({
+    product,
+    candidateRange,
+    evaluationContext,
+    timezoneName: projection.meta.timezone
+  });
+  const candidateStatus = requiredGroups.length ? summarizeStatuses(requiredGroups.map(group => group.status)) : candidateRange.endMs <= evaluationContext.evaluatedAtMs ? 'past' : 'available';
+  const maxPartySize = requiredGroups.length ? requiredGroups.reduce((min, group) => Math.min(min, group.maxPartySize), Number.MAX_SAFE_INTEGER) : 0;
+  const remainingCapacity = requiredGroups.length ? requiredGroups.reduce((min, group) => Math.min(min, group.remainingCapacity), Number.MAX_SAFE_INTEGER) : 0;
+  const maxCapacity = requiredGroups.length ? requiredGroups.reduce((min, group) => Math.min(min, group.maxCapacity), Number.MAX_SAFE_INTEGER) : 0;
+  const status = gate?.status || candidateStatus;
+  return {
+    status,
+    maxPartySize: gate ? 0 : Number.isFinite(maxPartySize) ? maxPartySize : 0,
+    remainingCapacity: status === 'past' || status === 'unavailable' ? 0 : Number.isFinite(remainingCapacity) ? remainingCapacity : 0,
+    maxCapacity: Number.isFinite(maxCapacity) ? maxCapacity : 0,
+    reasonCodes: gate?.reasonCodes || Array.from(new Set(requiredGroups.flatMap(group => group.reasonCodes)))
   };
 }
-function autoAssignResources(contextInput, query = {}) {
-  const baseContext = normalizePlannerContext(contextInput);
-  const projection = queryPlannerAvailability(baseContext, query);
-  const assignments = [];
-  const conflicts = [];
-  const missingTimeProductIds = new Set();
-  for (const interval of projection.demandIntervals) {
-    if (interval.source === 'duration' && !query.startTime) {
-      const productKey = String(interval.productId);
-      if (!missingTimeProductIds.has(productKey)) {
-        missingTimeProductIds.add(productKey);
-        conflicts.push({
-          type: 'missing_time',
-          message: 'duration 商品需要先确定开始时间后才能自动分配资源',
-          productId: interval.productId
-        });
+function evaluateCandidate(projection, candidate, request) {
+  const product = request.productIndex?.get(String(candidate.productId)) || projection.products.find(item => sameId(item.id, candidate.productId));
+  if (!product) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'candidate.productId 不存在于 projection.products', {
+      candidate
+    });
+  }
+  const candidateRangeCacheKey = getCandidateRangeCacheKey(candidate);
+  const candidateRange = request.candidateRangeCache?.get(candidateRangeCacheKey) || (() => {
+    const normalized = normalizeAbsoluteRange(getCandidateBookingRange(candidate), projection.meta.timezone);
+    return normalized ? toIndexedRange(normalized) : null;
+  })();
+  if (!candidateRange) {
+    throw availabilityError('INVALID_TARGET_FILTER', 'candidate 时间范围非法', {
+      candidate
+    });
+  }
+  if (request.candidateRangeCache && !request.candidateRangeCache.has(candidateRangeCacheKey)) {
+    request.candidateRangeCache.set(candidateRangeCacheKey, candidateRange);
+  }
+  const evaluationContext = request.evaluationContext || buildEvaluationContext({
+    projection,
+    evaluatedAt: request.evaluatedAt,
+    resourceIds: request.resourceIds,
+    requirementSelections: request.requirementSelections
+  });
+  const requestedPartySize = normalizePartySize(request.partySize);
+  const partySize = requestedPartySize ?? 1;
+  const selectionsByGroupKey = evaluationContext.selectionsByGroupKey;
+  const requirementGroups = (product.requirementGroups || []).map(requirementGroup => {
+    const required = requirementGroup.required !== false;
+    const minimum = Math.max(required ? 1 : 0, Number(requirementGroup.min ?? (required ? 1 : 0)) || 0);
+    const maximum = Math.max(minimum, Number(requirementGroup.max ?? Math.max(minimum, 1)) || Math.max(minimum, 1));
+    const selection = selectionsByGroupKey.get(requirementGroup.id) || selectionsByGroupKey.get(String(requirementGroup.formId ?? ''));
+    const matchedResources = (request.groupResourceIndex?.get([String(product.id), requirementGroup.id].join(':')) || projection.resources.filter(resource => matchesRequirementGroup(requirementGroup, resource, product, partySize)).filter(resource => !evaluationContext.resourceIdSet || evaluationContext.resourceIdSet.has(String(resource.id)))).filter(resource => !selection || selection.resourceIds.some(resourceId => sameId(resourceId, resource.id)));
+    const options = matchedResources.map(resource => {
+      const matchedCell = aggregateMatchedCells(product.id, requirementGroup.id, resource.id, candidateRange, request.cellIndex?.get([String(product.id), requirementGroup.id, String(resource.id)].join(':')) || []);
+      if (!matchedCell) {
+        const isPast = candidateRange.endMs <= evaluationContext.evaluatedAtMs;
+        return {
+          resourceId: resource.id,
+          resourceName: resource.name,
+          resourceFormId: resource.formId,
+          policyId: resource.raw?.policy_id,
+          resourceType: resource.resourceType,
+          status: isPast ? 'past' : 'unavailable',
+          maxPartySize: 0,
+          reasonCodes: isPast ? ['past'] : ['outside_resource_window']
+        };
       }
-      continue;
-    }
-    const contextWithAssignments = withAssignmentEvents(baseContext, assignments);
-    const candidateResources = getQueryResources(contextWithAssignments.resources, query).filter(resource => {
-      const requirements = interval.resourceRequirements || [];
-      if (!requirements.length) return true;
-      return requirements.some(requirement => matchesResourceRequirement(resource, requirement));
+      const remainingCapacity = matchedCell.remainingCapacity;
+      const maxCapacity = matchedCell.maxCapacity;
+      const isPast = candidateRange.endMs <= evaluationContext.evaluatedAtMs;
+      const maxPartySize = isPast ? 0 : Math.max(0, remainingCapacity || 0);
+      const requiredCapacity = resolveRequiredCapacity(requirementGroup, product, requestedPartySize);
+      const status = (() => {
+        if (isPast) return 'past';
+        if (matchedCell.status === 'unavailable') return 'unavailable';
+        if ((remainingCapacity || 0) < requiredCapacity) return 'full';
+        if ((remainingCapacity || 0) < (maxCapacity || resource.capacity)) return 'limited';
+        return 'available';
+      })();
+      return {
+        resourceId: resource.id,
+        resourceName: resource.name,
+        resourceFormId: resource.formId,
+        policyId: resource.raw?.policy_id,
+        resourceType: resource.resourceType,
+        status,
+        remainingCapacity,
+        maxCapacity,
+        maxPartySize,
+        reasonCodes: isPast ? Array.from(new Set([...matchedCell.reasonCodes, 'past'])) : matchedCell.reasonCodes,
+        matchedCell
+      };
     });
-    const availableCell = candidateResources.map(resource => evaluateResourceForInterval({
-      resource,
-      interval,
-      context: contextWithAssignments
-    })).find(cell => cell.status === 'available' || cell.status === 'limited');
-    if (!availableCell?.resourceId) {
-      conflicts.push({
-        type: 'missing_resource',
-        message: '无法为商品自动分配可用资源',
-        productId: interval.productId
-      });
-      continue;
+    const availableOptions = options.filter(option => option.status === 'available' || option.status === 'limited');
+    const totalResourceCount = options.length;
+    const availableResourceCount = availableOptions.length;
+    const groupMaxPartySize = availableOptions.reduce((max, option) => Math.max(max, option.maxPartySize), 0);
+    let status = 'available';
+    if (candidateRange.endMs <= evaluationContext.evaluatedAtMs) {
+      status = 'past';
+    } else if (availableResourceCount < minimum) {
+      status = options.some(option => option.status === 'full' || option.status === 'limited' || option.status === 'available') ? 'full' : 'unavailable';
+    } else if (options.every(option => option.status === 'available')) {
+      status = 'available';
+    } else {
+      status = 'limited';
     }
-    assignments.push({
-      productId: interval.productId,
-      resourceId: availableCell.resourceId,
-      start_at: interval.start_at,
-      end_at: interval.end_at,
-      capacityRequired: interval.capacityRequired
+    return {
+      groupId: requirementGroup.id,
+      formId: requirementGroup.formId,
+      title: requirementGroup.title,
+      code: requirementGroup.code,
+      resourceType: requirementGroup.resourceType,
+      required,
+      min: minimum,
+      max: maximum,
+      status,
+      availableResourceCount,
+      totalResourceCount,
+      maxPartySize: groupMaxPartySize,
+      remainingCapacity: Math.max(...availableOptions.map(option => option.remainingCapacity || 0), 0),
+      maxCapacity: Math.max(...availableOptions.map(option => option.maxCapacity || 0), 0),
+      reasonCodes: Array.from(new Set(options.flatMap(option => option.reasonCodes))),
+      options
+    };
+  });
+  const requiredGroups = requirementGroups.filter(group => group.required);
+  const requiredStatuses = requiredGroups.map(group => group.status);
+  const gate = evaluateCandidateTimeGate({
+    product,
+    candidateRange,
+    evaluationContext,
+    timezoneName: projection.meta.timezone
+  });
+  const candidateStatus = requiredGroups.length ? summarizeStatuses(requiredStatuses) : candidateRange.endMs <= evaluationContext.evaluatedAtMs ? 'past' : 'available';
+  const maxPartySize = requiredGroups.length ? requiredGroups.reduce((min, group) => Math.min(min, group.maxPartySize), Number.MAX_SAFE_INTEGER) : 0;
+  const selectedAssignments = requirementGroups.flatMap(group => {
+    const selection = selectionsByGroupKey.get(group.groupId) || selectionsByGroupKey.get(String(group.formId ?? ''));
+    if (!selection && !(request.allowImplicitSelection && group.required)) return [];
+    const availableOptions = group.options.filter(option => option.status === 'available' || option.status === 'limited');
+    const selectedOptions = selection ? availableOptions.slice(0, group.max) : availableOptions.slice(0, Math.max(group.min, 1));
+    const originalGroup = (product.requirementGroups || []).find(item => item.id === group.groupId) || {
+      id: group.groupId,
+      resourceType: group.resourceType,
+      min: group.min,
+      max: group.max
+    };
+    return selectedOptions.map(selectedOption => ({
+      productId: product.id,
+      resourceId: selectedOption.resourceId,
+      formId: group.formId,
+      startAt: candidate.bookingStartAt || candidate.startAt,
+      endAt: candidate.bookingEndAt || candidate.endAt,
+      capacityRequired: resolveRequiredCapacity(originalGroup, product, requestedPartySize),
+      scheduleId: candidate.primaryScheduleRef?.scheduleId,
+      timeSlotId: candidate.primaryScheduleRef?.timeSlotId
+    }));
+  });
+  return {
+    item: {
+      ...candidate,
+      status: gate?.status || candidateStatus,
+      maxPartySize: gate ? 0 : Number.isFinite(maxPartySize) ? maxPartySize : 0,
+      reasonCodes: gate?.reasonCodes || Array.from(new Set(requiredGroups.flatMap(group => group.reasonCodes))),
+      requirementGroups
+    },
+    assignments: gate ? [] : selectedAssignments,
+    gate: gate || undefined
+  };
+}
+function assertTimeCandidates(request) {
+  if (request.target === 'time' && (!Array.isArray(request.candidates) || request.candidates.length === 0)) {
+    throw availabilityError('MISSING_TIME_CANDIDATES', 'target=time 必须传非空 candidates', {
+      request
     });
   }
-  return {
-    assignments,
-    conflicts
+}
+function assertSelectedRanges(request) {
+  if (request.target === 'resource' && (!Array.isArray(request.selectedRanges) || request.selectedRanges.length === 0)) {
+    throw availabilityError('MISSING_SELECTED_RANGE', 'target=resource 必须传非空 selectedRanges', {
+      request
+    });
+  }
+}
+function assertRangesWithinProjection(projection, ranges) {
+  const coverage = {
+    start: toDateTime(projection.meta.coverage.startAt, projection.meta.timezone),
+    end: toDateTime(projection.meta.coverage.endAt, projection.meta.timezone)
   };
+  ranges.forEach(range => {
+    const displayRange = normalizeAbsoluteRange(range, projection.meta.timezone);
+    const bookingRange = normalizeAbsoluteRange(getCandidateBookingRange(range), projection.meta.timezone);
+    if (!displayRange || !bookingRange) {
+      throw availabilityError('INVALID_TARGET_FILTER', '候选时间范围非法', {
+        range
+      });
+    }
+    if (!contains(coverage, displayRange) || !contains(coverage, bookingRange)) {
+      throw availabilityError('OUT_OF_PROJECTION_COVERAGE', '候选时间范围超出 projection.coverage', {
+        range,
+        coverage: projection.meta.coverage
+      });
+    }
+  });
 }
-function withAssignmentEvents(context, assignments) {
-  if (!assignments.length) return context;
-  return {
-    ...context,
-    externalEvents: [...context.externalEvents, ...assignments.map(assignment => ({
-      resourceId: assignment.resourceId,
-      start_at: assignment.start_at,
-      end_at: assignment.end_at,
-      pax: assignment.capacityRequired || 1,
-      source: 'selection'
-    }))]
-  };
-}
-function validateAssignments(contextInput, selection) {
-  if (selection.assignments.length > 0) {
-    const context = normalizePlannerContext(contextInput);
-    const conflicts = [];
-    for (let index = 0; index < selection.assignments.length; index += 1) {
-      const assignment = selection.assignments[index];
-      const product = context.products.find(item => sameId(item.id, assignment.productId));
-      const resource = context.resources.find(item => sameId(item.id, assignment.resourceId));
-      if (!product) {
-        conflicts.push({
-          type: 'missing_resource',
-          message: 'assignment 对应的商品不存在',
-          productId: assignment.productId
-        });
-        continue;
-      }
-      if (!resource) {
-        conflicts.push({
-          type: 'missing_resource',
-          message: 'assignment 对应的资源不存在',
-          productId: assignment.productId,
-          resourceId: assignment.resourceId
-        });
-        continue;
-      }
-      const start = (0, _dayjs.default)(assignment.start_at);
-      const end = (0, _dayjs.default)(assignment.end_at);
-      const interval = {
-        id: `${assignment.productId}:${assignment.resourceId}:${assignment.start_at}:${assignment.end_at}`,
-        productId: assignment.productId,
-        source: product.kind === 'session' ? 'session' : product.kind === 'venue_slot' ? 'venue_slot' : 'duration',
-        date: start.format('YYYY-MM-DD'),
-        start_at: assignment.start_at,
-        end_at: assignment.end_at,
-        durationMinutes: Math.max(1, end.diff(start, 'minute')),
-        quantity: Math.max(1, Number(product.quantity || 1)),
-        capacityRequired: Math.max(1, Number(assignment.capacityRequired || product.capacityRequired || 1)),
-        resourceRequirements: product.resourceRequirements || []
+function queryAvailabilityProjection(projection, request) {
+  const normalizedPartySize = normalizePartySize(request.partySize);
+  const evaluatedAt = formatDateTime((0, _localClock.localDateToScalar)(new Date()), projection.meta.timezone, (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)());
+  if (request.target === 'time') {
+    assertTimeCandidates(request);
+    assertRangesWithinProjection(projection, request.candidates);
+  }
+  if (request.target === 'resource') {
+    assertSelectedRanges(request);
+    assertRangesWithinProjection(projection, request.selectedRanges);
+  }
+  const productIdSet = request.productIds?.length ? new Set(request.productIds.map(String)) : null;
+  const productIndex = buildProductIndex(projection);
+  const cellIndex = buildAvailabilityCellIndex(projection);
+  const groupResourceIndex = buildGroupResourceIndex({
+    projection,
+    resourceIds: request.resourceIds,
+    partySize: normalizedPartySize
+  });
+  const candidateRangeCache = new Map();
+  const evaluationContext = buildEvaluationContext({
+    projection,
+    evaluatedAt,
+    resourceIds: request.resourceIds
+  });
+  if (request.target === 'time') {
+    const candidates = dedupeProductRanges(request.candidates);
+    const candidatesByProduct = new Map();
+    candidates.forEach(candidate => {
+      const key = String(candidate.productId);
+      candidatesByProduct.set(key, [...(candidatesByProduct.get(key) || []), candidate]);
+    });
+    const data = projection.products.filter(product => !productIdSet || productIdSet.has(String(product.id))).map(product => ({
+      productId: product.id,
+      title: product.title,
+      times: (candidatesByProduct.get(String(product.id)) || []).map(candidate => evaluateCandidate(projection, candidate, {
+        partySize: normalizedPartySize,
+        resourceIds: request.resourceIds,
+        evaluatedAt,
+        cellIndex,
+        productIndex,
+        groupResourceIndex,
+        candidateRangeCache,
+        evaluationContext
+      }).item)
+    })).filter(group => group.times.length > 0);
+    return {
+      target: 'time',
+      evaluatedAt,
+      snapshotId: projection.meta.snapshotId,
+      data
+    };
+  }
+  if (request.target === 'resource') {
+    const selectedRanges = dedupeProductRanges(request.selectedRanges);
+    const rangesByProduct = new Map();
+    selectedRanges.forEach(candidate => {
+      const key = String(candidate.productId);
+      rangesByProduct.set(key, [...(rangesByProduct.get(key) || []), candidate]);
+    });
+    const data = projection.products.filter(product => !productIdSet || productIdSet.has(String(product.id))).map(product => ({
+      productId: product.id,
+      title: product.title,
+      ranges: (rangesByProduct.get(String(product.id)) || []).map(candidate => {
+        const evaluated = evaluateCandidate(projection, candidate, {
+          partySize: normalizedPartySize,
+          resourceIds: request.resourceIds,
+          evaluatedAt,
+          cellIndex,
+          productIndex,
+          groupResourceIndex,
+          candidateRangeCache,
+          evaluationContext
+        }).item;
+        return {
+          range: candidate,
+          status: evaluated.status,
+          maxPartySize: evaluated.maxPartySize,
+          reasonCodes: evaluated.reasonCodes,
+          requirementGroups: evaluated.requirementGroups
+        };
+      })
+    })).filter(group => group.ranges.length > 0);
+    return {
+      target: 'resource',
+      evaluatedAt,
+      snapshotId: projection.meta.snapshotId,
+      data
+    };
+  }
+  const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const candidateGroups = getProductTimeRanges(projection, {
+    productIds: request.productIds,
+    dateRange,
+    resourceIds: request.resourceIds,
+    partySize: normalizedPartySize
+  }, {
+    evaluatedAt
+  });
+  const candidateGroupMap = new Map(candidateGroups.map(group => [String(group.productId), group]));
+  if (request.target === 'date') {
+    const data = projection.products.filter(product => !productIdSet || productIdSet.has(String(product.id))).map(product => {
+      const group = candidateGroupMap.get(String(product.id)) || {
+        productId: product.id,
+        title: product.title,
+        kind: product.kind,
+        ranges: []
       };
-      const cell = evaluateResourceForInterval({
-        resource,
-        interval,
-        context
+      const byDate = new Map();
+      group.ranges.forEach(candidate => {
+        const evaluated = evaluateCandidateSummary(projection, candidate, {
+          partySize: normalizedPartySize,
+          resourceIds: request.resourceIds,
+          evaluatedAt,
+          cellIndex,
+          productIndex,
+          groupResourceIndex,
+          candidateRangeCache,
+          evaluationContext
+        });
+        const aggregate = byDate.get(candidate.date) || {
+          availableCount: 0,
+          totalCount: 0,
+          maxPartySize: 0,
+          remainingCapacity: 0,
+          maxCapacity: 0,
+          reasonCodeSet: new Set(),
+          statusAggregate: createStatusAggregate()
+        };
+        aggregate.totalCount += 1;
+        if (evaluated.status === 'available' || evaluated.status === 'limited') {
+          aggregate.availableCount += 1;
+        }
+        aggregate.maxPartySize = Math.max(aggregate.maxPartySize, evaluated.maxPartySize);
+        aggregate.remainingCapacity += evaluated.remainingCapacity;
+        aggregate.maxCapacity += evaluated.maxCapacity;
+        pushStatusAggregate(aggregate.statusAggregate, evaluated.status);
+        evaluated.reasonCodes.forEach(reasonCode => aggregate.reasonCodeSet.add(reasonCode));
+        byDate.set(candidate.date, aggregate);
       });
-      if (cell.status !== 'available' && cell.status !== 'limited') {
-        conflicts.push(...cell.conflicts);
-      }
-      const priorContext = withAssignmentEvents(context, selection.assignments.slice(0, index));
-      const selfConflictCell = evaluateResourceForInterval({
-        resource,
-        interval,
-        context: priorContext
+      const dates = enumerateDates(dateRange.startDate, dateRange.endDate).map(date => {
+        const aggregate = byDate.get(date);
+        return {
+          date,
+          status: aggregate ? summarizeStatusAggregate(aggregate.statusAggregate) : 'unavailable',
+          availableCount: aggregate?.availableCount || 0,
+          totalCount: aggregate?.totalCount || 0,
+          maxPartySize: aggregate?.maxPartySize || 0,
+          remainingCapacity: aggregate?.remainingCapacity || 0,
+          maxCapacity: aggregate?.maxCapacity || 0,
+          reasonCodes: aggregate ? Array.from(aggregate.reasonCodeSet) : []
+        };
+      });
+      return {
+        productId: product.id,
+        title: product.title,
+        dates
+      };
+    });
+    return {
+      target: 'date',
+      evaluatedAt,
+      snapshotId: projection.meta.snapshotId,
+      data
+    };
+  }
+  const data = projection.products.filter(product => !productIdSet || productIdSet.has(String(product.id))).map(product => {
+    const group = candidateGroupMap.get(String(product.id)) || {
+      productId: product.id,
+      title: product.title,
+      kind: product.kind,
+      ranges: []
+    };
+    const productStatusAggregate = createStatusAggregate();
+    const productReasonCodeSet = new Set();
+    const dateStatusMap = new Map();
+    let availableTimeCount = 0;
+    let totalTimeCount = 0;
+    let maxPartySize = 0;
+    group.ranges.forEach(candidate => {
+      const evaluated = evaluateCandidateSummary(projection, candidate, {
+        partySize: normalizedPartySize,
+        resourceIds: request.resourceIds,
+        evaluatedAt,
+        cellIndex,
+        productIndex,
+        groupResourceIndex,
+        candidateRangeCache,
+        evaluationContext
       });
-      if (selfConflictCell.status !== 'available' && selfConflictCell.status !== 'limited') {
-        conflicts.push(...selfConflictCell.conflicts.map(conflict => ({
-          ...conflict,
-          type: 'cart_overlap',
-          message: '本次选择中存在资源时间冲突'
-        })));
+      totalTimeCount += 1;
+      if (evaluated.status === 'available' || evaluated.status === 'limited') {
+        availableTimeCount += 1;
       }
-    }
+      maxPartySize = Math.max(maxPartySize, evaluated.maxPartySize);
+      pushStatusAggregate(productStatusAggregate, evaluated.status);
+      evaluated.reasonCodes.forEach(reasonCode => productReasonCodeSet.add(reasonCode));
+      const dateAggregate = dateStatusMap.get(candidate.date) || createStatusAggregate();
+      pushStatusAggregate(dateAggregate, evaluated.status);
+      dateStatusMap.set(candidate.date, dateAggregate);
+    });
+    const availableDateCount = Array.from(dateStatusMap.values()).filter(aggregate => {
+      const status = summarizeStatusAggregate(aggregate);
+      return status === 'available' || status === 'limited';
+    }).length;
+    const totalDateCount = dateStatusMap.size;
+    const status = summarizeStatusAggregate(productStatusAggregate);
+    const item = {
+      productId: group.productId,
+      title: group.title,
+      status,
+      reasonCodes: Array.from(productReasonCodeSet),
+      availableDateCount,
+      totalDateCount,
+      availableTimeCount,
+      totalTimeCount,
+      maxPartySize
+    };
     return {
-      ok: conflicts.length === 0,
-      conflicts
+      productId: product.id,
+      title: product.title,
+      item
+    };
+  });
+  return {
+    target: 'product',
+    evaluatedAt,
+    snapshotId: projection.meta.snapshotId,
+    data
+  };
+}
+function summarizeDateStatus(statuses) {
+  if (!statuses.length) return 'unavailable';
+  if (statuses.some(status => status === 'available')) return 'available';
+  if (statuses.some(status => status === 'limited')) return 'limited';
+  if (statuses.some(status => status === 'full')) return 'full';
+  if (statuses.every(status => status === 'past')) return 'past';
+  return 'unavailable';
+}
+function summarizeProductStatus(statuses) {
+  if (!statuses.length) return 'unavailable';
+  if (statuses.some(status => status === 'available')) return 'available';
+  if (statuses.some(status => status === 'limited')) return 'limited';
+  if (statuses.some(status => status === 'full')) return 'full';
+  if (statuses.every(status => status === 'past')) return 'past';
+  return 'unavailable';
+}
+function validateAvailabilitySelection(projection, params) {
+  const normalizedPartySize = normalizePartySize(params.partySize);
+  const normalizedBookingCount = normalizeBookingCount(params.bookingCount);
+  assertRangesWithinProjection(projection, [params.candidate]);
+  const productIndex = buildProductIndex(projection);
+  const evaluatedAt = formatDateTime((0, _localClock.localDateToScalar)(new Date()), projection.meta.timezone, (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)());
+  const evaluated = evaluateCandidate(projection, params.candidate, {
+    partySize: normalizedPartySize,
+    evaluatedAt,
+    requirementSelections: params.requirementSelections,
+    allowImplicitSelection: false,
+    cellIndex: buildAvailabilityCellIndex(projection),
+    productIndex,
+    groupResourceIndex: buildGroupResourceIndex({
+      projection,
+      partySize: normalizedPartySize
+    }),
+    candidateRangeCache: new Map(),
+    evaluationContext: buildEvaluationContext({
+      projection,
+      evaluatedAt,
+      requirementSelections: params.requirementSelections
+    })
+  });
+  const conflicts = [];
+  if (evaluated.gate) {
+    conflicts.push({
+      code: evaluated.gate.conflictCode,
+      message: evaluated.gate.status === 'past' ? '候选时间已过期' : '候选时间不满足预订时间门禁',
+      reasonCodes: evaluated.gate.reasonCodes,
+      productId: params.candidate.productId,
+      candidateKey: params.candidate.key
+    });
+    return {
+      ok: false,
+      status: evaluated.gate.status === 'past' ? 'past' : 'conflict',
+      assignments: [],
+      conflicts,
+      availability: evaluated.item
     };
   }
-  const projection = queryPlannerAvailability(contextInput, {
-    productIds: selection.productIds,
-    date: selection.date,
-    startTime: selection.startTime,
-    endTime: selection.endTime,
-    resourceIds: selection.resourceIds,
-    mode: selection.mode
+  const requiredGroups = evaluated.item.requirementGroups.filter(group => group.required);
+  const findSelectionForGroup = group => params.requirementSelections.find(selection => selection.requirementGroupId && selection.requirementGroupId === group.groupId || selection.formId !== undefined && sameId(selection.formId, group.formId));
+  requiredGroups.forEach(group => {
+    const selection = findSelectionForGroup(group);
+    const selectedCount = new Set((selection?.resourceIds || []).map(String)).size;
+    if (selectedCount < group.min) {
+      conflicts.push({
+        code: 'missing_resource',
+        message: `资源组 ${group.groupId} 缺少已选资源`,
+        productId: params.candidate.productId,
+        requirementGroupId: group.groupId,
+        formId: group.formId,
+        candidateKey: params.candidate.key
+      });
+      return;
+    }
+    if (selectedCount > group.max) {
+      conflicts.push({
+        code: 'invalid_selection_count',
+        message: `资源组 ${group.groupId} 已选资源数量超出上限`,
+        productId: params.candidate.productId,
+        requirementGroupId: group.groupId,
+        formId: group.formId,
+        candidateKey: params.candidate.key
+      });
+      return;
+    }
+    if (group.status === 'available' || group.status === 'limited') return;
+    conflicts.push({
+      code: group.status === 'past' ? 'past' : group.status === 'full' ? 'resource_full' : 'missing_resource',
+      message: `资源组 ${group.groupId} 当前不可提交`,
+      productId: params.candidate.productId,
+      requirementGroupId: group.groupId,
+      formId: group.formId,
+      candidateKey: params.candidate.key
+    });
+  });
+  params.requirementSelections.forEach(selection => {
+    const matchedGroup = evaluated.item.requirementGroups.find(group => selection.requirementGroupId ? group.groupId === selection.requirementGroupId : sameId(group.formId, selection.formId));
+    if (!matchedGroup) {
+      conflicts.push({
+        code: 'invalid_requirement_group',
+        message: '选择的资源组不属于当前商品',
+        productId: params.candidate.productId,
+        requirementGroupId: selection.requirementGroupId,
+        formId: selection.formId,
+        candidateKey: params.candidate.key
+      });
+      return;
+    }
+    const selectedCount = new Set(selection.resourceIds.map(String)).size;
+    if (!matchedGroup.required && (selectedCount < matchedGroup.min || selectedCount > matchedGroup.max)) {
+      conflicts.push({
+        code: 'invalid_selection_count',
+        message: `资源组 ${matchedGroup.groupId} 已选资源数量不满足 ${matchedGroup.min}-${matchedGroup.max}`,
+        productId: params.candidate.productId,
+        requirementGroupId: matchedGroup.groupId,
+        formId: matchedGroup.formId,
+        candidateKey: params.candidate.key
+      });
+    }
+    selection.resourceIds.forEach(resourceId => {
+      const option = matchedGroup?.options.find(item => sameId(item.resourceId, resourceId));
+      const matchedCell = option?.matchedCell;
+      const remainingCapacity = matchedCell?.remainingCapacity;
+      if (option && (option.status === 'available' || option.status === 'limited') && remainingCapacity !== undefined) {
+        const capacityPerBooking = normalizedPartySize ?? 1;
+        const availableQuantity = Math.max(0, Math.floor(remainingCapacity / capacityPerBooking));
+        if (normalizedBookingCount > availableQuantity) {
+          conflicts.push({
+            code: 'resource_capacity_exceeded',
+            message: `所选资源「${option.resourceName || String(resourceId)}」当前最多可预订 ${availableQuantity} 个`,
+            productId: params.candidate.productId,
+            requirementGroupId: matchedGroup?.groupId,
+            formId: matchedGroup?.formId,
+            resourceId,
+            resourceName: option.resourceName,
+            candidateKey: params.candidate.key,
+            requestedQuantity: normalizedBookingCount,
+            availableQuantity,
+            remainingCapacity,
+            capacityPerBooking
+          });
+          return;
+        }
+      }
+      if (!option || option.status !== 'available' && option.status !== 'limited') {
+        conflicts.push({
+          code: 'resource_unavailable',
+          message: `资源 ${String(resourceId)} 当前不可提交`,
+          productId: params.candidate.productId,
+          requirementGroupId: matchedGroup?.groupId,
+          formId: matchedGroup?.formId,
+          resourceId,
+          candidateKey: params.candidate.key
+        });
+      }
+    });
   });
-  const conflicts = projection.cells.filter(cell => cell.status !== 'available' && cell.status !== 'limited').flatMap(cell => cell.conflicts);
   return {
-    ok: conflicts.length === 0,
-    conflicts
+    ok: conflicts.length === 0 && (evaluated.item.status === 'available' || evaluated.item.status === 'limited'),
+    status: conflicts.length === 0 ? evaluated.item.status : 'conflict',
+    assignments: evaluated.assignments,
+    conflicts,
+    availability: evaluated.item
   };
 }