@pisell/pisellos 2.3.71 → 2.3.73

package/lib/modules/ResourcePlanner/planner.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,918 +14,2025 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/modules/ResourcePlanner/planner.ts
 var planner_exports = {};
 __export(planner_exports, {
-  DEFAULT_RESOURCE_PLANNER_CONTEXT: () => DEFAULT_RESOURCE_PLANNER_CONTEXT,
-  DEFAULT_RESOURCE_PLANNER_SELECTION: () => DEFAULT_RESOURCE_PLANNER_SELECTION,
-  autoAssignResources: () => autoAssignResources,
-  buildDemandIntervals: () => buildDemandIntervals,
-  evaluateResourceForInterval: () => evaluateResourceForInterval,
-  normalizePlannerContext: () => normalizePlannerContext,
-  queryPlannerAvailability: () => queryPlannerAvailability,
-  resolveAssignableSlots: () => resolveAssignableSlots,
-  validateAssignments: () => validateAssignments
+  createAvailabilityProjection: () => createAvailabilityProjection,
+  getProductTimeRanges: () => getProductTimeRanges,
+  queryAvailabilityProjection: () => queryAvailabilityProjection,
+  validateAvailabilitySelection: () => validateAvailabilitySelection
 });
 module.exports = __toCommonJS(planner_exports);
-var import_dayjs = __toESM(require("dayjs"));
-var DEFAULT_RESOURCE_PLANNER_CONTEXT = {
-  products: [],
-  resources: [],
-  externalEvents: [],
-  slotDurationMinutes: 30,
-  businessStartTime: "09:00",
-  businessEndTime: "18:00"
+var import_types = require("./types");
+var import_localClock = require("./localClock");
+var DEFAULT_SLOT_STEP_MINUTES = 30;
+var DEFAULT_BUSINESS_HOURS = {
+  startTime: "09:00",
+  endTime: "18:00"
 };
-var 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 import_types.AvailabilityError(code, message, details);
 }
 function sameId(left, right) {
+  if (left === void 0 || left === null || right === void 0 || right === null)
+    return false;
   return String(left) === String(right);
 }
-function dateOf(value) {
-  return (0, import_dayjs.default)(value).format("YYYY-MM-DD");
+function uniqById(values = []) {
+  const map = /* @__PURE__ */ new Map();
+  values.forEach((value) => {
+    map.set(String(value), value);
+  });
+  return Array.from(map.values());
 }
-function timeOf(value) {
-  return (0, import_dayjs.default)(value).format("HH:mm");
+function normalizePartySize(partySize) {
+  if (partySize === void 0 || partySize === null)
+    return void 0;
+  const normalized = Number(partySize);
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw availabilityError("INVALID_TARGET_FILTER", "partySize 必须是正整数", {
+      partySize
+    });
+  }
+  return normalized;
 }
-function toDateTime(date, time) {
-  if (/^\d{4}-\d{2}-\d{2}/.test(time))
-    return (0, import_dayjs.default)(time);
-  return (0, import_dayjs.default)(`${date} ${time.length === 5 ? `${time}:00` : time}`);
+function normalizeBookingCount(bookingCount) {
+  if (bookingCount === void 0 || bookingCount === null)
+    return 1;
+  const normalized = Number(bookingCount);
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw availabilityError("INVALID_TARGET_FILTER", "bookingCount 必须是正整数", {
+      bookingCount
+    });
+  }
+  return normalized;
 }
-function overlaps(startA, endA, startB, endB) {
-  return startA.isBefore(endB) && endA.isAfter(startB);
+function toDateTime(value, _timezoneName) {
+  try {
+    return (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(value));
+  } catch (_error) {
+    return Number.NaN;
+  }
 }
-function containsRange(outerStart, outerEnd, innerStart, innerEnd) {
-  return !innerStart.isBefore(outerStart) && !innerEnd.isAfter(outerEnd);
+function toDateStart(value, _timezoneName) {
+  try {
+    return (0, import_localClock.localDateToScalarStart)(value);
+  } catch (_error) {
+    return Number.NaN;
+  }
 }
-function maxDayjs(left, right) {
-  return left.isAfter(right) ? left : right;
+function toDateEnd(value, _timezoneName) {
+  const start = toDateStart(value);
+  return Number.isFinite(start) ? (0, import_localClock.addLocalCalendarDays)(start, 1) - 1 : Number.NaN;
 }
-function minDayjs(left, right) {
-  return left.isBefore(right) ? left : right;
+function toDateTimeInDate(date, time, _timezoneName) {
+  return toDateTime(`${date}T${time.length === 5 ? `${time}:00` : time}`);
 }
-function addDays(start, end) {
-  const result = [];
-  let cursor = (0, import_dayjs.default)(start);
-  const finalDay = (0, import_dayjs.default)(end);
-  while (!cursor.isAfter(finalDay, "day")) {
-    result.push(cursor.format("YYYY-MM-DD"));
-    cursor = cursor.add(1, "day");
-  }
-  return result;
+function addMinutesZoned(value, minutes, _timezoneName) {
+  return (0, import_localClock.addLocalMinutes)(value, minutes);
 }
-function getQueryProducts(products, query) {
-  var _a;
-  if (!((_a = query.productIds) == null ? void 0 : _a.length))
-    return products;
-  return products.filter((product) => query.productIds.some((id) => sameId(id, product.id)));
+function ceilToTenMinutes(value, _timezoneName) {
+  return (0, import_localClock.ceilLocalScalarToTenMinutes)(value);
 }
-function getQueryResources(resources, query) {
-  var _a;
-  if (!((_a = query.resourceIds) == null ? void 0 : _a.length))
-    return resources;
-  return resources.filter((resource) => query.resourceIds.some((id) => sameId(id, resource.id)));
+function nextDate(value, _timezoneName) {
+  return (0, import_localClock.nextDate)(value);
 }
-function matchesResourceRequirement(resource, requirement) {
-  var _a;
-  const isFormlessCandidate = resource.formId == null;
-  const formMatches = requirement.formId == null || isFormlessCandidate || sameId(requirement.formId, resource.formId);
-  const resourceMatches = !((_a = requirement.resourceIds) == null ? void 0 : _a.length) || isFormlessCandidate || requirement.resourceIds.some((id) => sameId(id, resource.id));
-  return formMatches && resourceMatches;
+function formatDateTime(value, _timezoneName, fixedOffsetMinutes) {
+  return (0, import_localClock.formatLocalDateTime)(value, fixedOffsetMinutes ?? (0, import_localClock.captureRuntimeOffsetMinutes)());
 }
-function resolveProductTitle(product) {
-  var _a, _b, _c;
-  const rawTitle = ((_a = product.raw) == null ? void 0 : _a.title) || ((_b = product.raw) == null ? void 0 : _b.name) || ((_c = product.raw) == null ? void 0 : _c.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 void 0;
-}
-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, import_dayjs.default)(schedule.start_at);
-        const end = (0, import_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 == null ? void 0 : 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 == null ? void 0 : 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 formatDate(value, _timezoneName) {
+  return (0, import_localClock.formatLocalDate)(value);
+}
+function formatTime(value, _timezoneName) {
+  return (0, import_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 !== void 0 && 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, import_localClock.addLocalCalendarDays)(base, unit);
+  if (unitType === "hours")
+    return (0, import_localClock.addLocalHours)(base, unit);
+  return (0, import_localClock.addLocalMinutes)(base, unit);
+}
+function evaluateCandidateTimeGate(params) {
+  const { product, candidateRange, evaluationContext, timezoneName } = params;
+  const now = evaluationContext.evaluatedAt;
+  if (candidateRange.endMs <= evaluationContext.evaluatedAtMs) {
+    return {
+      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 !== void 0) {
+    const futureDay = normalizeNonNegativeNumber(policy.futureDay);
+    const lastAllowedDateOrdinal = (0, import_localClock.dateOrdinalFromLocalDate)(formatDate(now)) + futureDay;
+    if ((0, import_localClock.dateOrdinalFromLocalDate)(formatDate(candidateRange.start)) > lastAllowedDateOrdinal) {
+      return {
+        status: "unavailable",
+        reasonCodes: ["booking_cutoff_future_day"],
+        conflictCode: "booking_cutoff"
+      };
     }
   }
-  return intervals;
+  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"
+    };
+  }
+  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 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 collectEventsByResource(resources, contextEvents) {
-  const eventsByResource = /* @__PURE__ */ new Map();
-  resources.forEach((resource) => {
-    eventsByResource.set(String(resource.id), getEventsForResource(resource, contextEvents));
-  });
-  return eventsByResource;
-}
-function getWorkingSegmentsForInterval(resource, interval) {
-  const intervalStart = (0, import_dayjs.default)(interval.start_at);
-  const intervalEnd = (0, import_dayjs.default)(interval.end_at);
-  return resource.times.map((time) => {
-    const start = maxDayjs((0, import_dayjs.default)(time.start_at), intervalStart);
-    const end = minDayjs((0, import_dayjs.default)(time.end_at), intervalEnd);
-    return { start, end };
-  }).filter((segment) => segment.end.isAfter(segment.start));
+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 mergeBusySegments(segments) {
-  const sorted = [...segments].filter((segment) => segment.end.isAfter(segment.start)).sort((left, right) => left.start.valueOf() - right.start.valueOf());
+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, import_dayjs.default)(event.start_at), (0, import_dayjs.default)(event.end_at))).map((event) => ({
-      start: maxDayjs((0, import_dayjs.default)(event.start_at), working.start),
-      end: minDayjs((0, import_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;
-}
-function buildCapacityRanges(params) {
-  const { workingSegments, events, maxCapacity, requiredCapacity } = params;
-  const ranges = [];
-  workingSegments.forEach((working) => {
-    const boundaries = /* @__PURE__ */ new Map([
-      [working.start.valueOf(), working.start],
-      [working.end.valueOf(), working.end]
-    ]);
-    events.forEach((event) => {
-      const eventStart = (0, import_dayjs.default)(event.start_at);
-      const eventEnd = (0, import_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);
+  return mergeRanges(results);
+}
+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, import_localClock.formatLocalDate)((0, import_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, import_dayjs.default)(event.start_at), (0, import_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, import_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 } : void 0,
+    requirementGroups: (product.requirementGroups || []).map((group) => normalizeRequirementGroup(product, group)),
+    sessionRules: (product.sessionRules || []).map((rule) => ({
+      ...rule,
+      weekdays: rule.weekdays ? [...rule.weekdays] : void 0,
+      dates: rule.dates ? [...rule.dates] : void 0,
+      includeDates: rule.includeDates ? [...rule.includeDates] : void 0,
+      excludeDates: rule.excludeDates ? [...rule.excludeDates] : void 0,
+      scheduleRef: rule.scheduleRef ? { ...rule.scheduleRef } : void 0
+    })),
+    sessionRanges: (product.sessionRanges || []).map((range) => {
+      var _a;
+      return {
+        ...range,
+        scheduleRefs: (_a = range.scheduleRefs) == null ? void 0 : _a.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) {
+  var _a, _b, _c;
+  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: ((_a = params.input) == null ? void 0 : _a.source) || params.fallbackSource,
+    scheduleIds: uniqById(((_b = params.input) == null ? void 0 : _b.scheduleIds) || []),
+    missingScheduleIds: uniqById(((_c = params.input) == null ? void 0 : _c.missingScheduleIds) || []),
+    windows
+  };
 }
-function evaluateResourceForInterval(params) {
-  const { resource, interval, context } = params;
-  const start = (0, import_dayjs.default)(interval.start_at);
-  const end = (0, import_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, import_dayjs.default)())) {
-    reasonCodes.push("past");
-    conflicts.push({
-      type: "past",
-      message: "时间已过期",
-      resourceId: resource.id,
-      productId: interval.productId
+function matchesRequirementGroup(requirementGroup, resource, product, partySize = 1) {
+  var _a;
+  if (requirementGroup.formId !== void 0 && resource.formId !== void 0 && !sameId(requirementGroup.formId, resource.formId)) {
+    return false;
+  }
+  if (((_a = requirementGroup.resourceIds) == null ? void 0 : _a.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 !== void 0 && occupancy.scheduleEventId !== null) {
+    return `scheduleEvent:${String(occupancy.resourceId)}:${String(occupancy.scheduleEventId)}`;
+  }
+  if (occupancy.bookingUid !== void 0 && occupancy.bookingUid !== null) {
+    return `bookingUid:${String(occupancy.resourceId)}:${String(occupancy.bookingUid)}`;
+  }
+  if (occupancy.productUid !== void 0 && 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, import_localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, import_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 = /* @__PURE__ */ 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
+            }))
+          });
+        }
+      });
     });
+  });
+  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 insideResourceTime = resource.times.some((time) => {
-    return containsRange((0, import_dayjs.default)(time.start_at), (0, import_dayjs.default)(time.end_at), start, end);
+  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) => {
+    if (key === "raw")
+      return;
+    const child = value[key];
+    if (child && (typeof child === "object" || typeof child === "function")) {
+      deepFreeze(child);
+    }
   });
-  if (!insideResourceTime) {
-    reasonCodes.push("outside_resource_time");
-    conflicts.push({
-      type: "outside_resource_time",
-      message: "所选时间不在资源可用时间内",
-      resourceId: resource.id,
-      productId: interval.productId
+  return value;
+}
+function createAvailabilityProjection(input) {
+  var _a, _b;
+  const coverage = normalizeCoverage(input);
+  const fixedOffsetMinutes = (0, import_localClock.captureRuntimeOffsetMinutes)();
+  const runtimeNow = (0, import_localClock.localDateToScalar)(/* @__PURE__ */ 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: ((_a = input.businessHours) == null ? void 0 : _a.startTime) || DEFAULT_BUSINESS_HOURS.startTime,
+    endTime: ((_b = input.businessHours) == null ? void 0 : _b.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) : void 0,
+    prepareParams: input.prepareParams ? cloneSnapshotMetadataValue(input.prepareParams) : void 0
+  };
+  const projectionBase = {
+    meta,
+    products,
+    resources,
+    resourceOccupancies
+  };
+  return deepFreeze({
+    ...projectionBase,
+    cells: buildCells(projectionBase)
+  });
+}
+function uniqByOccupancy(occupancies) {
+  const map = /* @__PURE__ */ new Map();
+  occupancies.forEach((occupancy) => {
+    map.set(dedupeOccupancyRefKey(occupancy), occupancy);
+  });
+  return Array.from(map.values());
+}
+function resolveProjectionDateRange(projection, requestDateRange) {
+  const startDate = (requestDateRange == null ? void 0 : requestDateRange.startDate) || projection.meta.coverage.startDate;
+  const endDate = (requestDateRange == null ? void 0 : requestDateRange.endDate) || projection.meta.coverage.endDate;
+  const isCanonicalDate = (value) => {
+    try {
+      return (0, import_localClock.formatLocalDate)((0, import_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
     });
   }
-  const events = getEventsForResource(resource, context.externalEvents);
-  const overlapping = events.filter((event) => overlaps(start, end, (0, import_dayjs.default)(event.start_at), (0, import_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 (startDate < projection.meta.coverage.startDate || endDate > projection.meta.coverage.endDate) {
+    throw availabilityError("OUT_OF_PROJECTION_COVERAGE", "查询范围超出 projection.coverage", {
+      requested: requestDateRange,
+      coverage: projection.meta.coverage
     });
   }
-  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";
-  }
-  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
+  return { startDate, endDate };
+}
+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 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 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 uniqueReasonCodes(cells) {
-  return Array.from(new Set(cells.flatMap((cell) => cell.reasonCodes || [])));
+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 == null ? void 0 : 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) => {
+    var _a;
+    const windows = ((_a = params.resourceWindowIndex) == null ? void 0 : _a.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 = /* @__PURE__ */ 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 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 materializeScheduleRules(rules, dateRange, timezoneName, fixedOffsetMinutes) {
+  const dates = enumerateDates(dateRange.startDate, dateRange.endDate);
+  const seen = /* @__PURE__ */ 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 !== void 0 && 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 == null ? void 0 : bestCell.remainingCapacity,
-      maxCapacity: (bestCell == null ? void 0 : bestCell.maxCapacity) || resource.capacity,
-      reasonCodes: uniqueReasonCodes(resourceCells)
-    };
+function matchesScheduleRuleDate(rule, date, _timezoneName) {
+  var _a, _b, _c, _d;
+  if ((_a = rule.includeDates) == null ? void 0 : _a.includes(date))
+    return true;
+  if ((_b = rule.excludeDates) == null ? void 0 : _b.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 ((_c = rule.dates) == null ? void 0 : _c.includes(date))
+      return true;
+    return false;
+  }
+  if (rule.mode === "weekly") {
+    if (!((_d = rule.weekdays) == null ? void 0 : _d.length))
+      return true;
+    const freq = Math.max(1, Number(rule.frequency || 1) || 1);
+    if (!rule.weekdays.includes((0, import_localClock.weekdayFromLocalDate)(date)))
+      return false;
+    if (!rule.startDate)
+      return true;
+    const targetWeekStart = (0, import_localClock.dateOrdinalFromLocalDate)(date) - (0, import_localClock.weekdayFromLocalDate)(date);
+    const ruleWeekStart = (0, import_localClock.dateOrdinalFromLocalDate)(rule.startDate) - (0, import_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, import_localClock.dateOrdinalFromLocalDate)(date) - (0, import_localClock.dateOrdinalFromLocalDate)(rule.startDate)) % freq === 0;
+  }
+  return true;
+}
+function mergeScheduleRefs(base, next) {
+  const map = /* @__PURE__ */ 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 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;
-    return {
-      date,
-      status: dateCells.length ? aggregateStatus(dateCells) : "unavailable",
-      availableCount,
-      totalCount: dateCells.length
-    };
+function buildProductIndex(projection) {
+  return new Map(projection.products.map((product) => [String(product.id), product]));
+}
+function buildGroupResourceIndex(params) {
+  var _a;
+  const resourceIdSet = ((_a = params.resourceIds) == null ? void 0 : _a.length) ? new Set(params.resourceIds.map(String)) : null;
+  const index = /* @__PURE__ */ 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 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 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");
-  return {
-    id: `${product.id}:${date}:${label}`,
+function getSessionRangesForProduct(projection, product, dateRange) {
+  const fixedOffsetMinutes = (0, import_localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, import_localClock.captureRuntimeOffsetMinutes)();
+  const ranges = (product.sessionRanges || []).map((range) => {
+    var _a;
+    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 {
+      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: (_a = range.scheduleRefs) == null ? void 0 : _a[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,
-    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 || []
-  };
+    timezone: projection.meta.timezone
+  }))]);
 }
-function buildTimeGrid(context, query, cells) {
+function dedupeProductRanges(ranges) {
+  const map = /* @__PURE__ */ 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 getProductTimeRanges(projection, request = {}) {
   var _a;
-  const date = query.date || ((_a = query.dateRange) == null ? void 0 : _a.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, import_dayjs.default)(interval.start_at);
-      const end = (0, import_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, import_dayjs.default)(item.start_at), (0, import_dayjs.default)(item.end_at), start, end));
+  const normalizedPartySize = normalizePartySize(request.partySize);
+  const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const fixedOffsetMinutes = (0, import_localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, import_localClock.captureRuntimeOffsetMinutes)();
+  const resourceWindowIndex = buildResourceWindowIndex(projection);
+  const filteredProductIdSet = ((_a = request.productIds) == null ? void 0 : _a.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 {
+        productId: product.id,
+        title: product.title,
+        kind: product.kind,
+        ranges: []
+      };
+    }
+    if (product.kind === "session" || product.kind === "venue_slot") {
       return {
-        startTime: label,
-        endTime: (0, import_dayjs.default)(interval.end_at).format("HH:mm"),
-        status: (cell == null ? void 0 : cell.status) || "unavailable",
-        resourceId: resource.id,
         productId: product.id,
-        remainingCapacity: cell == null ? void 0 : cell.remainingCapacity,
-        maxCapacity: (cell == null ? void 0 : cell.maxCapacity) || resource.capacity,
-        reasonCodes: (cell == null ? void 0 : cell.reasonCodes) || ["outside_available_range"]
+        title: product.title,
+        kind: product.kind,
+        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, ranges2) => current === null ? ranges2 : intersectRangeLists(current, ranges2), null) || [] : null;
+    const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
+    const durationMinutes = Math.max(1, Number(product.durationMinutes || 30) || 30);
+    const timeSliceMinutes = projection.meta.defaults.slotStepMinutes;
+    const durationAnchor = ceilToTenMinutes(
+      toDateTime(projection.meta.durationCandidateAnchorAt, projection.meta.timezone),
+      projection.meta.timezone
+    );
+    const ranges = [];
+    baseRanges.forEach((range) => {
+      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({
+            key: `${String(product.id)}:${cursor}:${bookingEnd}`,
+            productId: product.id,
+            source: "duration_window",
+            startAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
+            endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+            bookingStartAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
+            bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+            date: formatDate(cursor, projection.meta.timezone),
+            startTime: formatTime(cursor, projection.meta.timezone),
+            endTime: formatTime(bookingEnd, projection.meta.timezone),
+            timezone: projection.meta.timezone,
+            scheduleRefs: []
+          });
+        }
+        cursor = addMinutesZoned(cursor, timeSliceMinutes, projection.meta.timezone);
+      }
     });
     return {
-      resourceId: resource.id,
-      resourceName: resource.name,
-      resourceFormId: resource.formId,
-      slots
+      productId: product.id,
+      title: product.title,
+      kind: product.kind,
+      ranges: dedupeProductRanges(ranges)
     };
   });
-  return { date, timeLabels, resources: rows };
 }
-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
-        }]
-      });
+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 void 0;
+  let cursor = candidateRange.start;
+  for (const item of overlapped) {
+    if (item.range.start > cursor)
+      return void 0;
+    if (item.range.end > cursor) {
+      cursor = item.range.end;
     }
-    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 }));
-    });
+    if (cursor >= candidateRange.end)
+      break;
   }
+  if (cursor < candidateRange.end)
+    return void 0;
+  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 !== void 0 || cell.maxCapacity !== void 0);
+  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 {
-    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
+    ...firstCell,
+    key: buildCellKey({
+      productId,
+      groupId: requirementGroupId,
+      resourceId,
+      start: candidateRange.start,
+      end: candidateRange.end
+    }),
+    startAt: formatDateTime(
+      candidateRange.start,
+      firstCell.timezone,
+      (0, import_localClock.extractFixedOffsetMinutes)(firstCell.startAt) ?? (0, import_localClock.captureRuntimeOffsetMinutes)()
+    ),
+    endAt: formatDateTime(
+      candidateRange.end,
+      firstCell.timezone,
+      (0, import_localClock.extractFixedOffsetMinutes)(firstCell.startAt) ?? (0, import_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)) : void 0,
+    maxCapacity: capacityCells.length ? Math.min(...capacityCells.map((cell) => cell.maxCapacity ?? Number.MAX_SAFE_INTEGER)) : void 0,
+    reasonCodes,
+    occupancyRefs
   };
 }
-function getIntervalRequirements(interval) {
-  return interval.resourceRequirements.length ? interval.resourceRequirements : [{
-    capacityRequired: interval.capacityRequired,
-    required: true
-  }];
+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;
+    }
+  }
+  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 void 0;
+    cells.push(cell);
+    if (clippedEndMs > cursorMs)
+      cursorMs = clippedEndMs;
+    if (cursorMs >= candidateEndMs)
+      break;
+  }
+  if (!cells.length || cursorMs < candidateEndMs)
+    return void 0;
+  const statuses = cells.map((cell) => cell.status);
+  const nonPastStatuses = statuses.filter((status2) => status2 !== "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 !== void 0 || cell.maxCapacity !== void 0);
+  return {
+    status,
+    remainingCapacity: capacityCells.length ? Math.min(...capacityCells.map((cell) => cell.remainingCapacity ?? Number.MAX_SAFE_INTEGER)) : void 0,
+    maxCapacity: capacityCells.length ? Math.min(...capacityCells.map((cell) => cell.maxCapacity ?? Number.MAX_SAFE_INTEGER)) : void 0,
+    reasonCodes: Array.from(new Set(cells.flatMap((cell) => cell.reasonCodes)))
+  };
 }
-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 === void 0)
-        return false;
-      if (cell.status !== "available" && cell.status !== "limited")
-        return false;
-      const cellStart = (0, import_dayjs.default)(cell.start_at);
-      const cellEnd = (0, import_dayjs.default)(cell.end_at);
-      const intervalStart = (0, import_dayjs.default)(interval.start_at);
-      const intervalEnd = (0, import_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 }];
-    });
-  });
-  groups.forEach((group, index) => {
-    var _a, _b;
-    if (group.length)
+function buildAvailabilityCellIndex(projection) {
+  const index = /* @__PURE__ */ new Map();
+  projection.cells.forEach((cell) => {
+    if (cell.requirementGroupId == null || cell.resourceId == null)
       return;
-    conflicts.push({
-      type: "missing_resource",
-      message: "没有匹配商品需求的可用资源",
-      productId: interval.productId,
-      resourceId: (_b = (_a = interval.resourceRequirements[index]) == null ? void 0 : _a.resourceIds) == null ? void 0 : _b[0]
+    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);
   });
-  return { groups, conflicts };
+  index.forEach((entries, key) => {
+    index.set(key, entries.sort((left, right) => left.range.startMs - right.range.startMs));
+  });
+  return index;
 }
-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 buildEvaluationContext(params) {
+  var _a;
+  const evaluatedAt = toDateTime(params.evaluatedAt || params.projection.meta.now, params.projection.meta.timezone);
+  const selectionsByGroupKey = /* @__PURE__ */ new Map();
+  (params.requirementSelections || []).forEach((selection) => {
+    const key = selection.requirementGroupId || String(selection.formId ?? "");
+    selectionsByGroupKey.set(key, selection);
+  });
+  return {
+    evaluatedAt,
+    evaluatedAtMs: evaluatedAt,
+    resourceIdSet: ((_a = params.resourceIds) == null ? void 0 : _a.length) ? new Set(params.resourceIds.map(String)) : null,
+    selectionsByGroupKey
+  };
 }
-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 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 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(/* @__PURE__ */ new Set([...params.matchedCell.reasonCodes || [], "past"])) : params.matchedCell.reasonCodes
   };
 }
-function buildSlotsForInterval(params) {
-  const { interval, candidates, query, context } = params;
-  const start = candidates.reduce(
-    (current, candidate) => maxDayjs(current, (0, import_dayjs.default)(candidate.cell.start_at)),
-    (0, import_dayjs.default)(interval.start_at)
-  );
-  const end = candidates.reduce(
-    (current, candidate) => minDayjs(current, (0, import_dayjs.default)(candidate.cell.end_at)),
-    (0, import_dayjs.default)(interval.end_at)
-  );
-  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
-  if (interval.source !== "duration" || query.startTime) {
-    const fixedStart = (0, import_dayjs.default)(interval.start_at);
-    const fixedEnd = (0, import_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
+function evaluateRequirementGroupSummary(params) {
+  var _a;
+  const { projection, product, requirementGroup, candidateRange, requestedPartySize, evaluationContext } = params;
+  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 = ((_a = params.groupResourceIndex) == null ? void 0 : _a.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 = /* @__PURE__ */ new Set();
+  let totalResourceCount = 0;
+  let availableResourceCount = 0;
+  let groupMaxPartySize = 0;
+  let groupRemainingCapacity = 0;
+  let groupMaxCapacity = 0;
+  matchedResources.forEach((resource) => {
+    var _a2;
+    totalResourceCount += 1;
+    const matchedCell = aggregateMatchedCellSummary(
+      candidateRange,
+      ((_a2 = params.cellIndex) == null ? void 0 : _a2.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 = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  projection.demandIntervals.forEach((interval) => {
-    const { groups, conflicts: groupConflicts } = buildAssignableCandidateGroups({
-      interval,
-      cells: projection.cells,
-      resources
+function evaluateCandidateSummary(projection, candidate, request) {
+  var _a, _b;
+  const product = ((_a = request.productIndex) == null ? void 0 : _a.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 = ((_b = request.candidateRangeCache) == null ? void 0 : _b.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 == null ? void 0 : 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 == null ? void 0 : 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 = /* @__PURE__ */ 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) {
+  var _a, _b;
+  const product = ((_a = request.productIndex) == null ? void 0 : _a.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 = ((_b = request.candidateRangeCache) == null ? void 0 : _b.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) => {
+    var _a2;
+    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 = (((_a2 = request.groupResourceIndex) == null ? void 0 : _a2.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) => {
+      var _a3;
+      const matchedCell = aggregateMatchedCells(
+        product.id,
+        requirementGroup.id,
+        resource.id,
+        candidateRange,
+        ((_a3 = request.cellIndex) == null ? void 0 : _a3.get([String(product.id), requirementGroup.id, String(resource.id)].join(":"))) || []
+      );
+      if (!matchedCell) {
+        const isPast2 = candidateRange.endMs <= evaluationContext.evaluatedAtMs;
+        return {
+          resourceId: resource.id,
+          resourceName: resource.name,
+          resourceFormId: resource.formId,
+          resourceType: resource.resourceType,
+          status: isPast2 ? "past" : "unavailable",
+          maxPartySize: 0,
+          reasonCodes: isPast2 ? ["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 maxPartySize2 = isPast ? 0 : Math.max(0, remainingCapacity || 0);
+      const requiredCapacity = resolveRequiredCapacity(requirementGroup, product, requestedPartySize);
+      const status2 = (() => {
+        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,
+        resourceType: resource.resourceType,
+        status: status2,
+        remainingCapacity,
+        maxCapacity,
+        maxPartySize: maxPartySize2,
+        reasonCodes: isPast ? Array.from(/* @__PURE__ */ 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 == null ? void 0 : 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) => {
+      var _a2, _b2;
+      return {
+        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: (_a2 = candidate.primaryScheduleRef) == null ? void 0 : _a2.scheduleId,
+        timeSlotId: (_b2 = candidate.primaryScheduleRef) == null ? void 0 : _b2.timeSlotId
+      };
+    });
+  });
+  return {
+    item: {
+      ...candidate,
+      status: (gate == null ? void 0 : gate.status) || candidateStatus,
+      maxPartySize: gate ? 0 : Number.isFinite(maxPartySize) ? maxPartySize : 0,
+      reasonCodes: (gate == null ? void 0 : gate.reasonCodes) || Array.from(new Set(requiredGroups.flatMap((group) => group.reasonCodes))),
+      requirementGroups
+    },
+    assignments: gate ? [] : selectedAssignments,
+    gate: gate || void 0
+  };
+}
+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 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 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 validateAssignments(contextInput, selection) {
-  if (selection.assignments.length > 0) {
-    const context = normalizePlannerContext(contextInput);
-    const conflicts2 = [];
-    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) {
-        conflicts2.push({
-          type: "missing_resource",
-          message: "assignment 对应的商品不存在",
-          productId: assignment.productId
-        });
-        continue;
-      }
-      if (!resource) {
-        conflicts2.push({
-          type: "missing_resource",
-          message: "assignment 对应的资源不存在",
-          productId: assignment.productId,
-          resourceId: assignment.resourceId
+function queryAvailabilityProjection(projection, request) {
+  var _a;
+  const normalizedPartySize = normalizePartySize(request.partySize);
+  const evaluatedAt = formatDateTime(
+    (0, import_localClock.localDateToScalar)(/* @__PURE__ */ new Date()),
+    projection.meta.timezone,
+    (0, import_localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, import_localClock.captureRuntimeOffsetMinutes)()
+  );
+  if (request.target === "time") {
+    assertTimeCandidates(request);
+    assertRangesWithinProjection(projection, request.candidates);
+  }
+  if (request.target === "resource") {
+    assertSelectedRanges(request);
+    assertRangesWithinProjection(projection, request.selectedRanges);
+  }
+  const productIdSet = ((_a = request.productIds) == null ? void 0 : _a.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 = /* @__PURE__ */ new Map();
+  const evaluationContext = buildEvaluationContext({
+    projection,
+    evaluatedAt,
+    resourceIds: request.resourceIds
+  });
+  if (request.target === "time") {
+    const candidates = dedupeProductRanges(request.candidates);
+    const candidatesByProduct = /* @__PURE__ */ new Map();
+    candidates.forEach((candidate) => {
+      const key = String(candidate.productId);
+      candidatesByProduct.set(key, [...candidatesByProduct.get(key) || [], candidate]);
+    });
+    const data2 = 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: data2
+    };
+  }
+  if (request.target === "resource") {
+    const selectedRanges = dedupeProductRanges(request.selectedRanges);
+    const rangesByProduct = /* @__PURE__ */ new Map();
+    selectedRanges.forEach((candidate) => {
+      const key = String(candidate.productId);
+      rangesByProduct.set(key, [...rangesByProduct.get(key) || [], candidate]);
+    });
+    const data2 = 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: data2
+    };
+  }
+  const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const candidateGroups = getProductTimeRanges(projection, {
+    productIds: request.productIds,
+    dateRange,
+    resourceIds: request.resourceIds,
+    partySize: normalizedPartySize
+  });
+  const candidateGroupMap = new Map(candidateGroups.map((group) => [String(group.productId), group]));
+  if (request.target === "date") {
+    const data2 = 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 byDate = /* @__PURE__ */ new Map();
+      group.ranges.forEach((candidate) => {
+        const evaluated = evaluateCandidateSummary(projection, candidate, {
+          partySize: normalizedPartySize,
+          resourceIds: request.resourceIds,
+          evaluatedAt,
+          cellIndex,
+          productIndex,
+          groupResourceIndex,
+          candidateRangeCache,
+          evaluationContext
         });
-        continue;
-      }
-      const start = (0, import_dayjs.default)(assignment.start_at);
-      const end = (0, import_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 || []
+        const aggregate = byDate.get(candidate.date) || {
+          availableCount: 0,
+          totalCount: 0,
+          maxPartySize: 0,
+          remainingCapacity: 0,
+          maxCapacity: 0,
+          reasonCodeSet: /* @__PURE__ */ 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);
+      });
+      const dates = enumerateDates(dateRange.startDate, dateRange.endDate).map((date) => {
+        const aggregate = byDate.get(date);
+        return {
+          date,
+          status: aggregate ? summarizeStatusAggregate(aggregate.statusAggregate) : "unavailable",
+          availableCount: (aggregate == null ? void 0 : aggregate.availableCount) || 0,
+          totalCount: (aggregate == null ? void 0 : aggregate.totalCount) || 0,
+          maxPartySize: (aggregate == null ? void 0 : aggregate.maxPartySize) || 0,
+          remainingCapacity: (aggregate == null ? void 0 : aggregate.remainingCapacity) || 0,
+          maxCapacity: (aggregate == null ? void 0 : aggregate.maxCapacity) || 0,
+          reasonCodes: aggregate ? Array.from(aggregate.reasonCodeSet) : []
+        };
+      });
+      return {
+        productId: product.id,
+        title: product.title,
+        dates
       };
-      const cell = evaluateResourceForInterval({ resource, interval, context });
-      if (cell.status !== "available" && cell.status !== "limited") {
-        conflicts2.push(...cell.conflicts);
-      }
-      const priorContext = withAssignmentEvents(
-        context,
-        selection.assignments.slice(0, index)
-      );
-      const selfConflictCell = evaluateResourceForInterval({
-        resource,
-        interval,
-        context: priorContext
+    });
+    return {
+      target: "date",
+      evaluatedAt,
+      snapshotId: projection.meta.snapshotId,
+      data: data2
+    };
+  }
+  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 = /* @__PURE__ */ new Set();
+    const dateStatusMap = /* @__PURE__ */ 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") {
-        conflicts2.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 status2 = summarizeStatusAggregate(aggregate);
+      return status2 === "available" || status2 === "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 {
+      productId: product.id,
+      title: product.title,
+      item
+    };
+  });
+  return {
+    target: "product",
+    evaluatedAt,
+    snapshotId: projection.meta.snapshotId,
+    data
+  };
+}
+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, import_localClock.localDateToScalar)(/* @__PURE__ */ new Date()),
+    projection.meta.timezone,
+    (0, import_localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, import_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: /* @__PURE__ */ 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: conflicts2.length === 0,
-      conflicts: conflicts2
+      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 !== void 0 && sameId(selection.formId, group.formId));
+  requiredGroups.forEach((group) => {
+    const selection = findSelectionForGroup(group);
+    const selectedCount = new Set(((selection == null ? void 0 : 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 == null ? void 0 : matchedGroup.options.find((item) => sameId(item.resourceId, resourceId));
+      const matchedCell = option == null ? void 0 : option.matchedCell;
+      const remainingCapacity = matchedCell == null ? void 0 : matchedCell.remainingCapacity;
+      if (option && (option.status === "available" || option.status === "limited") && remainingCapacity !== void 0) {
+        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 == null ? void 0 : matchedGroup.groupId,
+            formId: matchedGroup == null ? void 0 : 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 == null ? void 0 : matchedGroup.groupId,
+          formId: matchedGroup == null ? void 0 : 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
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DEFAULT_RESOURCE_PLANNER_CONTEXT,
-  DEFAULT_RESOURCE_PLANNER_SELECTION,
-  autoAssignResources,
-  buildDemandIntervals,
-  evaluateResourceForInterval,
-  normalizePlannerContext,
-  queryPlannerAvailability,
-  resolveAssignableSlots,
-  validateAssignments
+  createAvailabilityProjection,
+  getProductTimeRanges,
+  queryAvailabilityProjection,
+  validateAvailabilitySelection
 });