@final-commerce/common 2.5.1-preprod.4 → 2.6.0-staging.2

package/dist/index.js

@@ -20,11 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ADYEN_ROLLOUT_COUNTRY_CODES: () => ADYEN_ROLLOUT_COUNTRY_CODES,
-  AFFIRM_COUNTRY_CODES: () => AFFIRM_COUNTRY_CODES,
-  AFFIRM_PRICE_PLANS: () => AFFIRM_PRICE_PLANS,
   AttributeType: () => AttributeType,
-  BNPL_METHOD_STATUS: () => BNPL_METHOD_STATUS,
-  BNPL_SKIP_REASON: () => BNPL_SKIP_REASON,
   BookingRatePeriod: () => BookingRatePeriod,
   BookingResourceKind: () => BookingResourceKind,
   BookingResourceStatus: () => BookingResourceStatus,
@@ -102,6 +98,7 @@ __export(index_exports, {
   UserTypes: () => UserTypes,
   addAmounts: () => addAmounts,
   amountToString: () => amountToString,
+  ancestorChain: () => ancestorChain,
   assertUnitSane: () => assertUnitSane,
   availableIn: () => availableIn,
   baseFor: () => baseFor,
@@ -115,6 +112,14 @@ __export(index_exports, {
   buildResolvedConfig: () => buildResolvedConfig,
   calculatePercentage: () => calculatePercentage,
   canTransition: () => canTransition,
+  cheapestCompositeItem: () => cheapestCompositeItem,
+  cheapestCompositePrice: () => cheapestCompositePrice,
+  compositeItemCost: () => compositeItemCost,
+  compositeItemUnavailable: () => compositeItemUnavailable,
+  compositeMakeable: () => compositeMakeable,
+  compositeModifierMismatches: () => compositeModifierMismatches,
+  compositeReservationMismatches: () => compositeReservationMismatches,
+  compositeVariantInStock: () => compositeVariantInStock,
   conditionSummary: () => conditionSummary,
   convertFixedFeeToLocalCurrency: () => convertFixedFeeToLocalCurrency,
   createAmount: () => createAmount,
@@ -149,15 +154,13 @@ __export(index_exports, {
   getPricingRegionFromCountry: () => getPricingRegionFromCountry,
   getSettlementTotal: () => getSettlementTotal,
   getTotalCollected: () => getTotalCollected,
-  hasInCartFlag: () => hasInCartFlag,
+  hasSellableChoice: () => hasSellableChoice,
   holdExpiresAt: () => holdExpiresAt,
   inferStatesFromLegacyStatus: () => inferStatesFromLegacyStatus,
   isAdyenRolloutCountry: () => isAdyenRolloutCountry,
-  isAffirmCountry: () => isAffirmCountry,
-  isAffirmPricePlan: () => isAffirmPricePlan,
+  isChoiceAvailableAtOutlet: () => isChoiceAvailableAtOutlet,
   isConditionOperator: () => isConditionOperator,
   isFulfillmentState: () => isFulfillmentState,
-  isInCart: () => isInCart,
   isPaymentState: () => isPaymentState,
   isSupportedCurrency: () => isSupportedCurrency,
   isSystemFamilyCode: () => isSystemFamilyCode,
@@ -166,6 +169,7 @@ __export(index_exports, {
   mapToLegacyStatus: () => mapToLegacyStatus,
   maxPrecisionFor: () => maxPrecisionFor,
   mergeFragment: () => mergeFragment,
+  modifiersSellable: () => modifiersSellable,
   multiplyAmount: () => multiplyAmount,
   normalizeMongoIdString: () => normalizeMongoIdString,
   occupancyIn: () => occupancyIn,
@@ -173,9 +177,14 @@ __export(index_exports, {
   parseCurrencyCode: () => parseCurrencyCode,
   parseStripeCurrencyCode: () => parseStripeCurrencyCode,
   planWindow: () => planWindow,
+  poolDemand: () => poolDemand,
+  poolOf: () => poolOf,
+  poolShortfall: () => poolShortfall,
+  poolStockAt: () => poolStockAt,
   presentAt: () => presentAt,
   removeFragment: () => removeFragment,
   resolveFamily: () => resolveFamily,
+  resolveModifiersForProduct: () => resolveModifiersForProduct,
   resolveTemplate: () => resolveTemplate,
   resolveUnit: () => resolveUnit,
   roundToPrecision: () => roundToPrecision,
@@ -191,7 +200,6 @@ __export(index_exports, {
   toMinorUnits: () => toMinorUnits,
   validateConfig: () => validateConfig,
   validateFragmentCompatibility: () => validateFragmentCompatibility,
-  validateOrderStatuses: () => validateOrderStatuses,
   violatesFinancialInvariant: () => violatesFinancialInvariant,
   windowEndsAt: () => windowEndsAt,
   withinPresence: () => withinPresence
@@ -437,7 +445,6 @@ var InventorySpecificActionType = /* @__PURE__ */ ((InventorySpecificActionType2
   InventorySpecificActionType2["PO_RECEIVED"] = "PO_RECEIVED";
   InventorySpecificActionType2["EXTERNAL_SALE"] = "EXTERNAL_SALE";
   InventorySpecificActionType2["EXTERNAL_RESTOCK"] = "EXTERNAL_RESTOCK";
-  InventorySpecificActionType2["CUSTOM"] = "CUSTOM";
   return InventorySpecificActionType2;
 })(InventorySpecificActionType || {});
 var ExtensionCategory = /* @__PURE__ */ ((ExtensionCategory2) => {
@@ -624,6 +631,7 @@ var ProductType = /* @__PURE__ */ ((ProductType2) => {
   ProductType2["SIMPLE"] = "simple";
   ProductType2["VARIABLE"] = "variable";
   ProductType2["BOOKING"] = "booking";
+  ProductType2["COMPOSITE"] = "composite";
   return ProductType2;
 })(ProductType || {});
 var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
@@ -1554,6 +1562,312 @@ function normalizeMongoIdString(value) {
   return null;
 }
 
+// utils/composite-price.util.ts
+var compositeItemCost = (item) => item.extraCharge * item.quantity;
+function cheapestCompositeItem(items) {
+  let cheapest;
+  items.forEach((item, index) => {
+    if (!item.available) return;
+    if (cheapest === void 0 || compositeItemCost(item) < compositeItemCost(items[cheapest])) cheapest = index;
+  });
+  return cheapest;
+}
+function cheapestCompositePrice(parts) {
+  let total = 0;
+  for (const part of parts) {
+    if (part.min === 0) continue;
+    const index = cheapestCompositeItem(part.items) ?? cheapestCompositeItem(part.items.map((item) => ({ ...item, available: true })));
+    if (index === void 0) return void 0;
+    total += part.min * compositeItemCost(part.items[index]);
+  }
+  return total;
+}
+
+// utils/modifier-resolution.util.ts
+function ancestorChain(categoryId, categoriesById) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([categoryId]);
+  let current = categoriesById.get(categoryId)?.parentId ?? void 0;
+  while (current && !seen.has(current)) {
+    chain.push(current);
+    seen.add(current);
+    current = categoriesById.get(current)?.parentId ?? void 0;
+  }
+  return chain;
+}
+function clampRule(rule) {
+  if (rule.min != null && rule.max != null && rule.min > rule.max) {
+    return { ...rule, min: rule.max };
+  }
+  return rule;
+}
+function mergeRules(a, b) {
+  const required = a.required || b.required;
+  const min = a.min == null ? b.min : b.min == null ? a.min : Math.max(a.min, b.min);
+  const max = a.max == null ? b.max : b.max == null ? a.max : Math.min(a.max, b.max);
+  return clampRule({ required, min, max, sortOrder: Math.min(a.sortOrder, b.sortOrder) });
+}
+function toRule(row) {
+  const required = row.required ?? false;
+  return clampRule({
+    required,
+    // `required` is the gate: a stale min left on a placement that went optional is
+    // ignored. A cleared min/max stays the explicit null it arrived as — nothing
+    // downstream distinguishes null from absent.
+    min: required ? row.min : void 0,
+    max: row.max,
+    sortOrder: row.sortOrder ?? 0
+  });
+}
+function toResolvedChoices(modifier) {
+  return (modifier.choices ?? []).map((choice, index) => ({
+    _id: String(choice._id),
+    name: choice.name,
+    price: choice.price ?? 0,
+    isDefault: choice.isDefault,
+    defaultQuantity: choice.defaultQuantity,
+    unavailableOutletIds: choice.unavailableOutletIds?.map(String),
+    sortOrder: choice.sortOrder ?? index
+  })).sort((a, b) => a.sortOrder - b.sortOrder);
+}
+function resolveModifiersForProduct(inputs) {
+  const categoriesById = new Map(
+    inputs.categories.filter((category) => !category.isDeleted).map((category) => [String(category._id), category])
+  );
+  const modifiersById = new Map(
+    inputs.modifiers.filter((modifier) => !modifier.isDeleted).map((modifier) => [String(modifier._id), modifier])
+  );
+  const directCategories = new Set(inputs.categoryIds.map(String));
+  const inheritedCategories = /* @__PURE__ */ new Set();
+  for (const categoryId of directCategories) {
+    for (const ancestor of ancestorChain(categoryId, categoriesById)) {
+      if (!directCategories.has(ancestor)) inheritedCategories.add(ancestor);
+    }
+  }
+  const rules = /* @__PURE__ */ new Map();
+  for (const placement of inputs.categoryModifiers) {
+    if (placement.isDeleted) continue;
+    const categoryId = String(placement.categoryId);
+    const precedence = directCategories.has(categoryId) ? 0 : inheritedCategories.has(categoryId) ? 1 : -1;
+    if (precedence === -1) continue;
+    const modifierId = String(placement.modifierId);
+    if (!modifiersById.has(modifierId)) continue;
+    const incoming = toRule(placement);
+    const existing = rules.get(modifierId);
+    if (!existing || precedence < existing.precedence) {
+      rules.set(modifierId, { precedence, rule: incoming });
+    } else if (precedence === existing.precedence) {
+      rules.set(modifierId, { precedence, rule: mergeRules(existing.rule, incoming) });
+    }
+  }
+  const resolved = [];
+  for (const [modifierId, { rule }] of rules) {
+    const modifier = modifiersById.get(modifierId);
+    if (!modifier) continue;
+    const required = rule.required;
+    resolved.push({
+      _id: modifierId,
+      name: modifier.name,
+      selectionType: modifier.selectionType,
+      allowQuantity: modifier.allowQuantity,
+      required,
+      // single-selection is implicitly capped at 1 — min/max are never carried.
+      min: modifier.selectionType === "single" ? void 0 : rule.min,
+      max: modifier.selectionType === "single" ? void 0 : rule.max,
+      sortOrder: rule.sortOrder,
+      choices: toResolvedChoices(modifier)
+    });
+  }
+  return resolved.sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
+}
+function isChoiceAvailableAtOutlet(choice, outletId) {
+  return !(choice.unavailableOutletIds ?? []).includes(outletId);
+}
+function hasSellableChoice(modifier, outletId) {
+  return modifier.choices.some((choice) => isChoiceAvailableAtOutlet(choice, outletId));
+}
+var modifiersSellable = (modifiers, outletId) => modifiers.every((modifier) => !modifier.required || hasSellableChoice(modifier, outletId));
+
+// utils/composite-availability.util.ts
+function poolStockAt(rows, outletId) {
+  if (!rows.some((row) => row.manageStock === true)) return null;
+  return Math.max(0, rows.find((row) => String(row.outletId) === outletId)?.quantity ?? 0);
+}
+function compositeVariantInStock(variantId, quantity, outlet) {
+  const shelf = outlet.shelves.get(variantId);
+  if (!shelf || shelf.unresolved) return false;
+  const onHand = outlet.poolStock.get(shelf.pool);
+  if (onHand === void 0) return false;
+  if (onHand === null || shelf.backorder) return true;
+  return onHand >= (shelf.unit ? toBase(quantity, shelf.unit) : quantity);
+}
+function compositeItemUnavailable(item, rows) {
+  const { outlet } = rows;
+  const sellableHere = (productId2) => !outlet || !outlet.hiddenProductIds.has(productId2) && !outlet.unsellableProductIds.has(productId2);
+  if (item.categoryId) {
+    const variants = rows.categoryVariants.get(String(item.categoryId));
+    if (!variants) return "deleted";
+    const offered = variants.filter((variantId2) => sellableHere(rows.variantProducts.get(variantId2) ?? ""));
+    if (!offered.length) return "empty";
+    if (!outlet) return null;
+    const unmarked = offered.filter((variantId2) => !outlet.markedVariantIds.has(variantId2));
+    if (!unmarked.length) return "marked_sold_out";
+    return unmarked.some((variantId2) => compositeVariantInStock(variantId2, item.quantity, outlet)) ? null : "out_of_stock";
+  }
+  const variantId = String(item.variantId);
+  const productId = rows.variantProducts.get(variantId);
+  if (!productId || !rows.productStatuses.has(productId)) return "deleted";
+  if (rows.productStatuses.get(productId) !== "active" /* ACTIVE */) return "inactive";
+  if (!outlet) return null;
+  if (outlet.hiddenProductIds.has(productId)) return "hidden";
+  if (outlet.unsellableProductIds.has(productId)) return "empty";
+  if (outlet.markedVariantIds.has(variantId)) return "marked_sold_out";
+  if (rows.bookableProductIds.has(productId)) {
+    if (!outlet.bookableSeats) return "by_date";
+    return (outlet.bookableSeats.get(productId) ?? 0) >= item.quantity ? null : "fully_booked";
+  }
+  return compositeVariantInStock(variantId, item.quantity, outlet) ? null : "out_of_stock";
+}
+function compositeMakeable(parts, rows) {
+  const { outlet } = rows;
+  if (!outlet) throw new Error("compositeMakeable counts at one outlet: rows.outlet is required");
+  const required = parts.map((part, partIndex) => ({ ...part, partIndex })).filter((part) => part.min > 0);
+  const isBookable = (variantId) => rows.bookableProductIds.has(rows.variantProducts.get(String(variantId)) ?? "");
+  if (required.some((part) => part.items.some((item) => item.variantId && isBookable(item.variantId))))
+    return { byDate: true };
+  const optionsOf = (item) => (item.categoryId ? rows.categoryVariants.get(String(item.categoryId)) ?? [] : [String(item.variantId)]).flatMap(
+    (variantId) => {
+      const reason = compositeItemUnavailable({ variantId, quantity: item.quantity }, rows);
+      const shelf = outlet.shelves.get(variantId);
+      if (reason && reason !== "out_of_stock" || !shelf) return [];
+      const stock = outlet.poolStock.get(shelf.pool);
+      const onHand = shelf.unresolved || stock === void 0 ? 0 : stock === null || shelf.backorder ? null : stock;
+      const perPick = shelf.unit ? toBase(item.quantity, shelf.unit) : item.quantity;
+      return [{ itemId: item.id, pool: shelf.pool, perPick, onHand }];
+    }
+  );
+  const counted = required.map((part) => ({ ...part, options: part.items.flatMap(optionsOf) }));
+  const order = [...counted].sort((a, b) => Number(a.options.length !== 1) - Number(b.options.length !== 1));
+  const picksLeft = (option, reserved) => option.onHand === null ? Infinity : Math.max(0, Math.floor((option.onHand - (reserved.get(option.pool) ?? 0)) / option.perPick));
+  const shortAt = (n) => {
+    const reserved = /* @__PURE__ */ new Map();
+    for (const part of order) {
+      let wanted = part.min * n;
+      const ranked = [...part.options].sort((a, b) => picksLeft(b, reserved) - picksLeft(a, reserved));
+      for (const option of ranked) {
+        if (wanted <= 0) break;
+        const taken = Math.min(wanted, picksLeft(option, reserved));
+        if (option.onHand !== null)
+          reserved.set(option.pool, (reserved.get(option.pool) ?? 0) + taken * option.perPick);
+        wanted -= taken;
+      }
+      if (wanted > 0) return part.partIndex;
+    }
+    return void 0;
+  };
+  const whyRows = [];
+  const rowPools = /* @__PURE__ */ new Map();
+  const makes = (has, uses) => has === null ? null : Math.floor(has / uses);
+  for (const part of counted) {
+    const [option] = part.options;
+    if (part.options.length === 1) {
+      const uses = option.perPick * part.min;
+      const row = whyRows.find((candidate) => rowPools.get(candidate) === option.pool);
+      if (!row) {
+        const created = { itemIds: [option.itemId], uses, has: option.onHand, makes: makes(option.onHand, uses) };
+        rowPools.set(created, option.pool);
+        whyRows.push(created);
+        continue;
+      }
+      row.itemIds.push(option.itemId);
+      row.uses += uses;
+      if (option.onHand === null) row.has = null;
+      row.makes = makes(row.has, row.uses);
+      continue;
+    }
+    const perPool = /* @__PURE__ */ new Map();
+    for (const candidate of part.options)
+      perPool.set(candidate.pool, Math.max(perPool.get(candidate.pool) ?? 0, picksLeft(candidate, /* @__PURE__ */ new Map())));
+    const total = [...perPool.values()].reduce((sum, picks) => sum + picks, 0);
+    const has = total === Infinity ? null : total;
+    whyRows.push({
+      itemIds: part.items.map((item) => item.id),
+      partIndex: part.partIndex,
+      uses: part.min,
+      has,
+      makes: makes(has, part.min)
+    });
+  }
+  if (counted.every((part) => part.options.some((option) => option.onHand === null)))
+    return { count: null, rows: whyRows };
+  const ceiling = Math.min(
+    ...counted.filter((part) => !part.options.some((option) => option.onHand === null)).map(
+      (part) => Math.floor(part.options.reduce((sum, option) => sum + picksLeft(option, /* @__PURE__ */ new Map()), 0) / part.min)
+    )
+  );
+  let [low, high] = [0, ceiling];
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (shortAt(mid) === void 0) low = mid;
+    else high = mid - 1;
+  }
+  const short = shortAt(low + 1);
+  const shortPart = counted.find((part) => part.partIndex === short);
+  const limitedBy = whyRows.findIndex(
+    (row) => shortPart?.options.length === 1 ? row.partIndex === void 0 && row.itemIds.includes(shortPart.options[0].itemId) : row.partIndex === short
+  );
+  return { count: low, rows: whyRows, ...limitedBy >= 0 ? { limitedBy } : {} };
+}
+var poolOf = (line) => line.stockVariantId || line.variantId;
+function poolDemand(lines) {
+  const demand = /* @__PURE__ */ new Map();
+  const add = (line, times) => demand.set(
+    poolOf(line),
+    (demand.get(poolOf(line)) ?? 0) + (line.unit ? toBase(line.quantity * times, line.unit) : line.quantity * times)
+  );
+  for (const line of lines) {
+    if (line.components) for (const component of line.components) add(component, line.quantity);
+    else add(line, 1);
+  }
+  return demand;
+}
+function poolShortfall(demand, poolStock, backordered = /* @__PURE__ */ new Set()) {
+  for (const [poolId, wanted] of demand) {
+    const available = poolStock.get(poolId);
+    if (available === null || available === void 0 || backordered.has(poolId)) continue;
+    if (wanted > available) return { poolId, available, wanted };
+  }
+  return null;
+}
+
+// utils/composite-reservation.util.ts
+function compositeModifierMismatches(lineItems) {
+  return lineItems.flatMap(
+    (line) => line.components?.length ? (line.modifiers ?? []).flatMap(
+      (modifier) => modifier.componentIndex !== void 0 && line.components[modifier.componentIndex] !== void 0 ? [] : [
+        `Modifier ${modifier.modifierName ?? "?"} on composite line ${line.internalId ?? "?"} names no component (componentIndex ${modifier.componentIndex}) \u2014 a composite has no modifiers of its own`
+      ]
+    ) : []
+  );
+}
+function compositeReservationMismatches(order) {
+  return (order.reservations ?? []).flatMap((reservation) => {
+    if (reservation.lineItemInternalId === void 0) return [];
+    const name = `Booking ${String(reservation.bookingId ?? "?")}`;
+    const line = order.lineItems?.find((candidate) => candidate.internalId === reservation.lineItemInternalId);
+    if (!line) return [`${name} names line ${reservation.lineItemInternalId}, which is not on the order`];
+    const component = reservation.componentIndex === void 0 ? void 0 : line.components?.[reservation.componentIndex];
+    if (!component) return [`${name} names no component ${reservation.componentIndex} of line ${line.internalId}`];
+    if (String(component.productId) !== String(reservation.productId))
+      return [
+        `${name} is for ${String(reservation.productId)}, but that component sold ${String(component.productId)}`
+      ];
+    if (reservation.price !== 0 || reservation.total !== 0)
+      return [`${name} carries money (${reservation.price}/${reservation.total}); its component already does`];
+    return [];
+  });
+}
+
 // units/family-code.ts
 var MAX_SLUG_LENGTH = 32;
 var FALLBACK_SLUG = "family";
@@ -2692,51 +3006,6 @@ function inferStatesFromLegacyStatus(order) {
   return { payment: "unpaid", fulfillment: "pending" };
 }
 
-// order-state-machine/in-cart.ts
-function hasInCartFlag(order) {
-  return order.inCart != null;
-}
-function isInCart(order) {
-  if (order.inCart != null) return order.inCart.active === true;
-  if (order.fulfillmentState) return order.fulfillmentState === "draft";
-  return (order.status ?? "").trim().toLowerCase() === "in-cart";
-}
-
-// order-state-machine/order-status.ts
-function validateOrderStatuses(statuses) {
-  if (!Array.isArray(statuses)) {
-    return [{ index: -1, field: "orderStatuses", message: "must be an array" }];
-  }
-  const errors = [];
-  const seen = /* @__PURE__ */ new Set();
-  statuses.forEach((raw, index) => {
-    const s = raw ?? {};
-    const add = (field, message) => errors.push({ index, field, message });
-    if (typeof s.id !== "string" || !s.id.trim()) add("id", "must be a non-empty string");
-    else if (seen.has(s.id)) add("id", `duplicate id "${s.id}"`);
-    else seen.add(s.id);
-    if (typeof s.label !== "string" || !s.label.trim()) add("label", "must be a non-empty string");
-    for (const field of ["color", "icon"]) {
-      if (s[field] !== void 0 && typeof s[field] !== "string") add(field, "must be a string");
-    }
-    if (s.fulfillmentState !== void 0 && !(typeof s.fulfillmentState === "string" && isFulfillmentState(s.fulfillmentState))) {
-      add("fulfillmentState", `"${String(s.fulfillmentState)}" is not a fulfillment state`);
-    }
-    if (s.requiresPaymentState !== void 0) {
-      if (!Array.isArray(s.requiresPaymentState) || s.requiresPaymentState.length === 0) {
-        add("requiresPaymentState", "must be a non-empty array of payment states");
-      } else {
-        for (const p of s.requiresPaymentState) {
-          if (!(typeof p === "string" && isPaymentState(p))) {
-            add("requiresPaymentState", `"${String(p)}" is not a payment state`);
-          }
-        }
-      }
-    }
-  });
-  return errors;
-}
-
 // order-state-machine/write-strategy.ts
 var LegacyWriteStrategy = class {
   applyState(_order) {
@@ -3248,7 +3517,9 @@ function buildGrid(rule, timeZone, from, to, now, busy = []) {
     const start = startAt.getTime();
     if (start < askedFrom || start >= askedTo) return false;
     if (start < notBefore || start > notAfter) return false;
-    return !blocked.some(({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom);
+    return !blocked.some(
+      ({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom
+    );
   }).sort((first, second) => +first.startAt - +second.startAt);
 }
 function slotsForWindow(grid, startAt, endAt) {
@@ -3367,7 +3638,14 @@ function buildAvailability({
     for (const slot of slots2) {
       const { taken, foreignProductId } = occupancyIn(mine, productId, slot.startAt, slot.bufferEndAt, shared);
       const free = foreignProductId ? 0 : Math.max(capacity - taken, 0);
-      const entry = byInstant.get(+slot.startAt) ?? { ...slot, capacity: 0, booked: 0, free: 0, resources: [], dayKey: shopDayKey(slot.startAt, resource.timeZone) };
+      const entry = byInstant.get(+slot.startAt) ?? {
+        ...slot,
+        capacity: 0,
+        booked: 0,
+        free: 0,
+        resources: [],
+        dayKey: shopDayKey(slot.startAt, resource.timeZone)
+      };
       entry.capacity += capacity;
       entry.booked += foreignProductId ? capacity : taken;
       entry.free += free;
@@ -3445,34 +3723,10 @@ var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
 function isAdyenRolloutCountry(alpha2) {
   return ADYEN_ROLLOUT_COUNTRY_CODES.has(alpha2);
 }
-var AFFIRM_PRICE_PLANS = ["core", "standard", "signature"];
-function isAffirmPricePlan(value) {
-  return typeof value === "string" && AFFIRM_PRICE_PLANS.includes(value);
-}
-var AFFIRM_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
-function isAffirmCountry(alpha2) {
-  return !!alpha2 && AFFIRM_COUNTRY_CODES.has(alpha2.toUpperCase());
-}
-var BNPL_METHOD_STATUS = {
-  ACTIVE: "active",
-  PENDING: "pending",
-  UNAVAILABLE: "unavailable",
-  UNKNOWN: "unknown"
-};
-var BNPL_SKIP_REASON = {
-  PENDING: "pending",
-  NO_SUPPORT_EMAIL: "no_support_email",
-  NO_CURRENCY: "no_currency",
-  NO_BUSINESS_LINE: "no_business_line"
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ADYEN_ROLLOUT_COUNTRY_CODES,
-  AFFIRM_COUNTRY_CODES,
-  AFFIRM_PRICE_PLANS,
   AttributeType,
-  BNPL_METHOD_STATUS,
-  BNPL_SKIP_REASON,
   BookingRatePeriod,
   BookingResourceKind,
   BookingResourceStatus,
@@ -3550,6 +3804,7 @@ var BNPL_SKIP_REASON = {
   UserTypes,
   addAmounts,
   amountToString,
+  ancestorChain,
   assertUnitSane,
   availableIn,
   baseFor,
@@ -3563,6 +3818,14 @@ var BNPL_SKIP_REASON = {
   buildResolvedConfig,
   calculatePercentage,
   canTransition,
+  cheapestCompositeItem,
+  cheapestCompositePrice,
+  compositeItemCost,
+  compositeItemUnavailable,
+  compositeMakeable,
+  compositeModifierMismatches,
+  compositeReservationMismatches,
+  compositeVariantInStock,
   conditionSummary,
   convertFixedFeeToLocalCurrency,
   createAmount,
@@ -3597,15 +3860,13 @@ var BNPL_SKIP_REASON = {
   getPricingRegionFromCountry,
   getSettlementTotal,
   getTotalCollected,
-  hasInCartFlag,
+  hasSellableChoice,
   holdExpiresAt,
   inferStatesFromLegacyStatus,
   isAdyenRolloutCountry,
-  isAffirmCountry,
-  isAffirmPricePlan,
+  isChoiceAvailableAtOutlet,
   isConditionOperator,
   isFulfillmentState,
-  isInCart,
   isPaymentState,
   isSupportedCurrency,
   isSystemFamilyCode,
@@ -3614,6 +3875,7 @@ var BNPL_SKIP_REASON = {
   mapToLegacyStatus,
   maxPrecisionFor,
   mergeFragment,
+  modifiersSellable,
   multiplyAmount,
   normalizeMongoIdString,
   occupancyIn,
@@ -3621,9 +3883,14 @@ var BNPL_SKIP_REASON = {
   parseCurrencyCode,
   parseStripeCurrencyCode,
   planWindow,
+  poolDemand,
+  poolOf,
+  poolShortfall,
+  poolStockAt,
   presentAt,
   removeFragment,
   resolveFamily,
+  resolveModifiersForProduct,
   resolveTemplate,
   resolveUnit,
   roundToPrecision,
@@ -3639,7 +3906,6 @@ var BNPL_SKIP_REASON = {
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
-  validateOrderStatuses,
   violatesFinancialInvariant,
   windowEndsAt,
   withinPresence