@fayz-ai/shop 0.9.0 → 0.10.0

package/README.md

@@ -17,6 +17,7 @@ It's provider-first by design. Ship a demo on `createMockShopProvider`, then dro
 - **Runtime** — `getShopProvider` / `setShopProvider` singleton wiring
 - **Tenancy** — `setShopTenantResolver` / `getShopTenantId` for multi-store isolation
 - **Public domain types** — products, orders, customers, discounts, shipping
+- **`StockStore` contract** (`@fayz-ai/shop/inventory`) — stock as an append-only ledger rather than a scalar, with a Supabase and an in-memory implementation held to one shared contract suite
 
 ## Install
 ```bash
@@ -31,8 +32,24 @@ import { setShopProvider, createSupabaseShopProvider } from '@fayz-ai/shop'
 setShopProvider(createSupabaseShopProvider({ /* supabase + storeId */ }))
 ```
 
+Stock is a ledger: movements are appended, balances are derived from them, and `available = on_hand − reserved`. The same code runs against either implementation.
+
+```ts
+import { createSupabaseStockStore } from '@fayz-ai/shop/inventory'
+
+const stock = createSupabaseStockStore()
+await stock.recordMovement({
+  variantId,
+  kind: 'receipt',            // vocabulary rows, not a hardcoded enum
+  reasonCode: 'purchase',
+  quantity: 12,               // signed; the kind's direction decides the sign
+  idempotencyKey: `po-1180:${variantId}`, // a retry returns the same movement
+})
+await stock.getAvailable(variantId)
+```
+
 ## Part of the Fayz SDK
 The commerce engine `@fayz-ai/storefront` renders and `@fayz-ai/plugin-shop` administers. Pair with `@fayz-ai/sdk`'s shop client for generated storefronts.
 
 ## Roadmap & contributing
-Built and evolving in the open. See the [Fayz SDK roadmap](../../docs/ROADMAP.md).
+Built and evolving in the open. See the [Fayz SDK roadmap](../../docs/platform/ROADMAP.md).

package/dist/admin.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+//# sourceMappingURL=admin.d.ts.map

package/dist/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../src/admin.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAA"}

package/dist/catalog.d.ts

@@ -1,4 +1,2 @@
-export { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS, svgPlaceholder } from './mock-catalog';
-export { buildMockCatalog } from './mock-catalog';
-export type { CatalogInput, CatalogProductInput, CatalogCategoryInput } from './mock-catalog';
+export * from './lib/catalog';
 //# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA"}

package/dist/catalog.js

@@ -1,4 +1,4 @@
-import './chunk-JR25TISO.js';
-export { MOCK_CATEGORIES, MOCK_DISCOUNTS, MOCK_PRODUCTS, buildMockCatalog, svgPlaceholder } from './chunk-CTKZ6O2J.js';
+import './chunk-FQPGE3YN.js';
+export { MOCK_CATEGORIES, MOCK_DISCOUNTS, MOCK_PRODUCTS, buildMockCatalog, svgPlaceholder } from './chunk-IKNGCRUM.js';
 //# sourceMappingURL=catalog.js.map
 //# sourceMappingURL=catalog.js.map

package/dist/chunk-3GERSY5F.js

@@ -0,0 +1,526 @@
+import { Registry } from '@fayz-ai/core';
+
+// src/rules/rule-types.ts
+var RULE_OPERATORS = ["gte", "lte", "gt", "lt", "eq", "ne", "in"];
+var APPLICATION_METHOD_TYPES = ["percentage", "fixed"];
+var APPLICATION_METHOD_TARGET_TYPES = ["order", "items", "shipping"];
+var APPLICATION_METHOD_ALLOCATIONS = ["each", "across", "once"];
+var PROMOTION_TYPES = ["standard", "buyget"];
+var PROMOTION_STATUSES = ["draft", "active", "inactive"];
+function cartSubtotal(cart) {
+  return roundCents(cart.items.reduce((sum, item) => sum + item.unitPrice * item.quantity, 0));
+}
+function roundCents(value) {
+  return Math.round(value * 100) / 100;
+}
+var RULE_ATTRIBUTE_FIELD_TYPES = ["text", "number", "boolean"];
+var ID_OPERATORS = ["eq", "ne", "in"];
+var NUMBER_OPERATORS = ["gte", "lte", "gt", "lt", "eq", "ne"];
+var ITEM_PATH_PREFIX = "items.";
+var CORE_RULE_ATTRIBUTES = [
+  {
+    key: "code",
+    path: "codes",
+    label: "Cupom informado",
+    fieldType: "text",
+    valueSource: null,
+    operators: ["eq", "in"]
+  },
+  {
+    key: "cart.subtotal",
+    path: "subtotal",
+    label: "Subtotal do carrinho",
+    fieldType: "number",
+    valueSource: null,
+    operators: NUMBER_OPERATORS
+  },
+  {
+    key: "item.quantity",
+    path: "items.quantity",
+    label: "Quantidade do item",
+    fieldType: "number",
+    valueSource: null,
+    operators: NUMBER_OPERATORS
+  },
+  {
+    key: "product.id",
+    path: "items.product_id",
+    label: "Produto",
+    fieldType: "text",
+    valueSource: "products",
+    operators: ID_OPERATORS
+  },
+  {
+    key: "product.category_id",
+    path: "items.category_id",
+    label: "Categoria do produto",
+    fieldType: "text",
+    valueSource: "categories",
+    operators: ID_OPERATORS
+  },
+  {
+    key: "product.collection_id",
+    path: "items.collection_id",
+    label: "Cole\xE7\xE3o do produto",
+    fieldType: "text",
+    valueSource: "collections",
+    operators: ID_OPERATORS
+  },
+  {
+    key: "customer.email",
+    path: "customer.email",
+    label: "E-mail do cliente",
+    fieldType: "text",
+    valueSource: null,
+    operators: ID_OPERATORS
+  },
+  {
+    key: "customer.tag",
+    path: "customer.tags",
+    label: "Tag do cliente",
+    fieldType: "text",
+    valueSource: "customer_tags",
+    operators: ["eq", "ne", "in"]
+  },
+  {
+    key: "shipping.region",
+    path: "shipping.region",
+    label: "Regi\xE3o de entrega",
+    fieldType: "text",
+    valueSource: "regions",
+    operators: ID_OPERATORS
+  }
+];
+var ruleAttributeRegistry = new Registry("ruleAttribute");
+var coreRegistered = false;
+function registerCoreRuleAttributes() {
+  if (coreRegistered && ruleAttributeRegistry.has("code")) return;
+  for (const attribute of CORE_RULE_ATTRIBUTES) {
+    ruleAttributeRegistry.register(attribute.key, attribute, {
+      title: attribute.label,
+      description: `Rule attribute (${attribute.fieldType}) \u2014 operators: ${attribute.operators.join(", ")}`,
+      source: "sdk"
+    });
+  }
+  coreRegistered = true;
+}
+function registerRuleAttribute(attribute, options = {}) {
+  registerCoreRuleAttributes();
+  if (!attribute.key) throw new Error("registerRuleAttribute: attribute.key is required");
+  if (!RULE_ATTRIBUTE_FIELD_TYPES.includes(attribute.fieldType)) {
+    throw new Error(
+      `registerRuleAttribute: "${attribute.key}" has unknown fieldType "${attribute.fieldType}". Valid field types: ${RULE_ATTRIBUTE_FIELD_TYPES.join(", ")}`
+    );
+  }
+  for (const op of attribute.operators) {
+    if (!RULE_OPERATORS.includes(op)) {
+      throw new Error(
+        `registerRuleAttribute: "${attribute.key}" declares unknown operator "${op}". Valid operators: ${RULE_OPERATORS.join(", ")}`
+      );
+    }
+  }
+  if (ruleAttributeRegistry.has(attribute.key) && !options.replace) {
+    throw new Error(
+      `registerRuleAttribute: attribute "${attribute.key}" is already registered. Registered attributes: ${listRuleAttributeKeys().join(", ")}`
+    );
+  }
+  ruleAttributeRegistry.register(attribute.key, attribute, {
+    title: attribute.label,
+    description: `Rule attribute (${attribute.fieldType}) \u2014 operators: ${attribute.operators.join(", ")}`,
+    source: "app",
+    ...options.meta
+  });
+}
+function resolveRuleAttribute(key) {
+  registerCoreRuleAttributes();
+  const attribute = ruleAttributeRegistry.get(key);
+  if (!attribute) {
+    throw new Error(`Unknown rule attribute "${key}". Registered attributes: ${listRuleAttributeKeys().join(", ")}`);
+  }
+  return attribute;
+}
+function hasRuleAttribute(key) {
+  registerCoreRuleAttributes();
+  return ruleAttributeRegistry.has(key);
+}
+function listRuleAttributeKeys() {
+  registerCoreRuleAttributes();
+  return ruleAttributeRegistry.ids().sort();
+}
+function listRuleAttributes() {
+  registerCoreRuleAttributes();
+  return ruleAttributeRegistry.list().map((entry) => entry.value).sort((a, b) => a.key.localeCompare(b.key));
+}
+function isItemScopedAttribute(attribute) {
+  return attribute.path.startsWith(ITEM_PATH_PREFIX);
+}
+function clearRuleAttributes() {
+  ruleAttributeRegistry.clear();
+  coreRegistered = false;
+}
+
+// src/rules/evaluator.ts
+var ITEM_FIELDS = {
+  quantity: "quantity",
+  unit_price: "unitPrice",
+  product_id: "productId",
+  category_id: "categoryId",
+  collection_id: "collectionId"
+};
+function itemValue(item, attribute) {
+  const field = ITEM_FIELDS[attribute.path.slice("items.".length)];
+  return field ? item[field] : void 0;
+}
+function cartValues(cart, attribute, context) {
+  if (attribute.key in context) return flatten(context[attribute.key]);
+  const root = {
+    subtotal: cartSubtotal(cart),
+    codes: (cart.codes ?? []).map((code) => code.trim().toUpperCase()),
+    customer: { email: cart.customer?.email ?? null, tags: cart.customer?.tags ?? [] },
+    shipping: { region: cart.region ?? null, total: cart.shippingTotal ?? null }
+  };
+  let value = root;
+  for (const segment of attribute.path.split(".")) {
+    if (value === null || typeof value !== "object") return [];
+    value = value[segment];
+  }
+  return flatten(value);
+}
+function flatten(value) {
+  if (value === null || value === void 0) return [];
+  return Array.isArray(value) ? value.filter((v) => v !== null && v !== void 0) : [value];
+}
+function scalarEq(a, b) {
+  if (typeof a === "string" && typeof b === "string") return a.toUpperCase() === b.toUpperCase();
+  return a === b;
+}
+function numeric(op, values, ruleValues) {
+  const bound = Number(ruleValues[0]);
+  if (!Number.isFinite(bound)) return false;
+  return values.some((value) => {
+    const n = Number(value);
+    return Number.isFinite(n) && op(n, bound);
+  });
+}
+function matchRuleValues(rule, values) {
+  switch (rule.operator) {
+    case "eq":
+    case "in":
+      return values.some((value) => rule.values.some((rv) => scalarEq(value, rv)));
+    case "ne":
+      return !values.some((value) => rule.values.some((rv) => scalarEq(value, rv)));
+    case "gt":
+      return numeric((a, b) => a > b, values, rule.values);
+    case "gte":
+      return numeric((a, b) => a >= b, values, rule.values);
+    case "lt":
+      return numeric((a, b) => a < b, values, rule.values);
+    case "lte":
+      return numeric((a, b) => a <= b, values, rule.values);
+  }
+}
+function ruleMatchesCart(rule, cart, context) {
+  const attribute = resolveRuleAttribute(rule.attribute);
+  if (isItemScopedAttribute(attribute) && !(attribute.key in context)) {
+    return cart.items.some((item) => matchRuleValues(rule, flatten(itemValue(item, attribute))));
+  }
+  return matchRuleValues(rule, cartValues(cart, attribute, context));
+}
+function ruleMatchesItem(rule, item, cart, context) {
+  const attribute = resolveRuleAttribute(rule.attribute);
+  if (isItemScopedAttribute(attribute) && !(attribute.key in context)) {
+    return matchRuleValues(rule, flatten(itemValue(item, attribute)));
+  }
+  return matchRuleValues(rule, cartValues(cart, attribute, context));
+}
+function rulesMatchCart(rules, cart, context = {}) {
+  return (rules ?? []).every((rule) => ruleMatchesCart(rule, cart, context));
+}
+function itemsMatching(rules, cart, context) {
+  const list = rules ?? [];
+  return cart.items.filter((item) => list.every((rule) => ruleMatchesItem(rule, item, cart, context)));
+}
+function promotionGateReason(promotion, cart, options = {}) {
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  if (promotion.status !== void 0 && promotion.status !== "active") return "inactive";
+  if (promotion.startsAt && promotion.startsAt > now) return "not_started";
+  if (promotion.endsAt && promotion.endsAt < now) return "expired";
+  if (promotion.usageLimit != null && (promotion.timesUsed ?? 0) >= promotion.usageLimit) return "usage_limit";
+  if (promotion.code) {
+    const entered = (cart.codes ?? []).map((code) => code.trim().toUpperCase());
+    if (!entered.includes(promotion.code.trim().toUpperCase())) return "code_not_entered";
+  } else if (promotion.isAutomatic === false) {
+    return "code_not_entered";
+  }
+  if (!rulesMatchCart(promotion.rules, cart, options.context ?? {})) return "rules_not_matched";
+  return null;
+}
+function clampPercent(value) {
+  return Math.min(Math.max(value, 0), 100);
+}
+function splitProportionally(total, weights) {
+  const sum = weights.reduce((acc, weight) => acc + weight, 0);
+  if (sum <= 0 || total <= 0) return weights.map(() => 0);
+  const cents = Math.round(total * 100);
+  const raw = weights.map((weight) => cents * weight / sum);
+  const floors = raw.map(Math.floor);
+  let remainder = cents - floors.reduce((acc, value) => acc + value, 0);
+  const order = raw.map((value, index) => ({ index, frac: value - Math.floor(value) })).sort((a, b) => b.frac - a.frac || a.index - b.index);
+  for (const { index } of order) {
+    if (remainder <= 0) break;
+    floors[index] += 1;
+    remainder -= 1;
+  }
+  return floors.map((value) => value / 100);
+}
+function lineId(item) {
+  return item.id ?? item.productId;
+}
+function unitDiscount(method, unitPrice) {
+  if (method.type === "percentage") return roundCents(unitPrice * clampPercent(method.value) / 100);
+  return Math.min(method.value, unitPrice);
+}
+function isBuyget(promotion) {
+  const min = promotion.applicationMethod.buyRulesMinQuantity;
+  return promotion.type === "buyget" || min != null && min >= 1;
+}
+function applyBuyget(promotion, cart, context) {
+  const method = promotion.applicationMethod;
+  const min = method.buyRulesMinQuantity ?? 1;
+  const per = method.applyToQuantity ?? 1;
+  const buyQty = itemsMatching(method.buyRules, cart, context).reduce((sum, item) => sum + item.quantity, 0);
+  const times = Math.floor(buyQty / Math.max(min, 1));
+  if (times <= 0 || per <= 0) return [];
+  let grantUnits = times * per;
+  if (method.maxQuantity != null) grantUnits = Math.min(grantUnits, method.maxQuantity);
+  if (grantUnits <= 0) return [];
+  const targets = itemsMatching(method.targetRules, cart, context).map((item) => ({ item, id: lineId(item) })).sort((a, b) => a.item.unitPrice - b.item.unitPrice || a.id.localeCompare(b.id));
+  if (targets.length === 0) {
+    const pins = (method.targetRules ?? []).filter((rule) => rule.attribute === "product.id" && (rule.operator === "eq" || rule.operator === "in")).flatMap((rule) => rule.values);
+    if (pins.length === 1 && typeof pins[0] === "string") {
+      return [{
+        action: "addFreeItem",
+        promotionId: promotion.id,
+        code: promotion.code ?? null,
+        productId: pins[0],
+        quantity: grantUnits
+      }];
+    }
+    return [];
+  }
+  const actions = [];
+  let remaining = grantUnits;
+  for (const target of targets) {
+    if (remaining <= 0) break;
+    const units = Math.min(target.item.quantity, remaining);
+    const amount = roundCents(unitDiscount(method, target.item.unitPrice) * units);
+    remaining -= units;
+    if (amount <= 0) continue;
+    actions.push({
+      action: "addItemDiscount",
+      promotionId: promotion.id,
+      code: promotion.code ?? null,
+      itemId: target.id,
+      amount
+    });
+  }
+  return actions;
+}
+function applyStandard(promotion, cart, context) {
+  const method = promotion.applicationMethod;
+  const code = promotion.code ?? null;
+  if (method.targetType === "shipping") {
+    const shipping = cart.shippingTotal ?? 0;
+    if (shipping <= 0) return [];
+    const amount = method.type === "percentage" ? roundCents(shipping * clampPercent(method.value) / 100) : roundCents(Math.min(method.value, shipping));
+    if (amount <= 0) return [];
+    return [{ action: "addShippingDiscount", promotionId: promotion.id, code, amount }];
+  }
+  const eligible = method.targetType === "order" ? cart.items.map((item) => ({ item, id: lineId(item) })) : itemsMatching(method.targetRules, cart, context).map((item) => ({ item, id: lineId(item) }));
+  if (eligible.length === 0) return [];
+  const lineTotals = eligible.map(({ item }) => roundCents(item.unitPrice * item.quantity));
+  const eligibleTotal = roundCents(lineTotals.reduce((sum, value) => sum + value, 0));
+  const emit = (amounts) => amounts.flatMap(
+    (amount, index) => amount > 0 ? [{ action: "addItemDiscount", promotionId: promotion.id, code, itemId: eligible[index].id, amount }] : []
+  );
+  const allocation = method.targetType === "order" ? "across" : method.allocation ?? "across";
+  if (allocation === "each") {
+    return emit(
+      eligible.map(({ item }) => {
+        const units = method.maxQuantity != null ? Math.min(item.quantity, method.maxQuantity) : item.quantity;
+        return roundCents(unitDiscount(method, item.unitPrice) * units);
+      })
+    );
+  }
+  if (allocation === "once") {
+    let cheapest = 0;
+    for (let i = 1; i < eligible.length; i++) {
+      if (eligible[i].item.unitPrice < eligible[cheapest].item.unitPrice) cheapest = i;
+    }
+    const amounts = eligible.map(() => 0);
+    amounts[cheapest] = unitDiscount(method, eligible[cheapest].item.unitPrice);
+    return emit(amounts);
+  }
+  const total = method.type === "percentage" ? roundCents(eligibleTotal * clampPercent(method.value) / 100) : roundCents(Math.min(method.value, eligibleTotal));
+  return emit(splitProportionally(total, lineTotals));
+}
+function totalRulesCount(promotion) {
+  return (promotion.rules?.length ?? 0) + (promotion.applicationMethod.targetRules?.length ?? 0) + (promotion.applicationMethod.buyRules?.length ?? 0);
+}
+function orderPromotions(promotions) {
+  return [...promotions].sort((a, b) => {
+    const buyget = Number(isBuyget(b)) - Number(isBuyget(a));
+    if (buyget !== 0) return buyget;
+    const specificity = totalRulesCount(b) - totalRulesCount(a);
+    if (specificity !== 0) return specificity;
+    return a.id.localeCompare(b.id);
+  });
+}
+function computePromotionActions(cart, promotions, options = {}) {
+  const context = options.context ?? {};
+  const actions = [];
+  for (const promotion of orderPromotions(promotions)) {
+    if (promotionGateReason(promotion, cart, options) !== null) continue;
+    actions.push(
+      ...isBuyget(promotion) ? applyBuyget(promotion, cart, context) : applyStandard(promotion, cart, context)
+    );
+  }
+  return actions;
+}
+function actionsDiscountTotal(actions) {
+  return roundCents(
+    actions.reduce((sum, action) => sum + ("amount" in action ? action.amount : 0), 0)
+  );
+}
+
+// src/rules/adapter.ts
+function storefrontDiscountToPromotion(discount) {
+  const code = discount.code.trim().toUpperCase();
+  return {
+    id: `config-discount:${code}`,
+    code,
+    type: "standard",
+    status: "active",
+    rules: [{ attribute: "code", operator: "eq", values: [code] }],
+    applicationMethod: { type: "percentage", value: discount.percent, targetType: "order" }
+  };
+}
+function discountToPromotion(discount) {
+  if (discount.type === "buy_x_get_y") return null;
+  const rules = [];
+  const code = discount.code ? discount.code.trim().toUpperCase() : null;
+  if (discount.method !== "automatic" && code) {
+    rules.push({ attribute: "code", operator: "eq", values: [code] });
+  }
+  if (discount.minSubtotal != null) {
+    rules.push({ attribute: "cart.subtotal", operator: "gte", values: [discount.minSubtotal] });
+  }
+  let targetRules;
+  if (discount.appliesTo === "products" && discount.productIds.length > 0) {
+    targetRules = [{ attribute: "product.id", operator: "in", values: [...discount.productIds] }];
+  } else if (discount.appliesTo === "categories" && discount.categoryIds.length > 0) {
+    targetRules = [{ attribute: "product.category_id", operator: "in", values: [...discount.categoryIds] }];
+  }
+  let applicationMethod;
+  if (discount.type === "free_shipping") {
+    applicationMethod = { type: "percentage", value: 100, targetType: "shipping" };
+  } else {
+    applicationMethod = {
+      type: discount.type === "percentage" ? "percentage" : "fixed",
+      value: discount.value,
+      // A scoped legacy coupon discounts its eligible lines; an unscoped one
+      // is order-wide. Same split 0027 makes in shop_place_order.
+      targetType: targetRules ? "items" : "order",
+      ...targetRules ? { allocation: "across", targetRules } : {}
+    };
+  }
+  return {
+    id: `discount:${discount.id}`,
+    code,
+    isAutomatic: discount.method === "automatic",
+    type: "standard",
+    status: discount.status === "active" ? "active" : "inactive",
+    rules,
+    applicationMethod,
+    startsAt: discount.startsAt || null,
+    endsAt: discount.endsAt || null,
+    usageLimit: discount.usageLimit,
+    timesUsed: discount.timesUsed
+  };
+}
+function previewCouponPercent(promotions, code, cart = { items: [] }, options = {}) {
+  const normalized = code.trim().toUpperCase();
+  if (!normalized) return { valid: false, percent: 0, reason: "not_found" };
+  const promotion = promotions.find((p) => (p.code ?? "").trim().toUpperCase() === normalized);
+  if (!promotion) return { valid: false, percent: 0, reason: "not_found" };
+  const reason = promotionGateReason(promotion, { ...cart, codes: [normalized] }, options);
+  if (reason === "inactive") return { valid: false, percent: 0, reason: "not_found" };
+  if (reason !== null) return { valid: false, percent: 0, reason };
+  const method = promotion.applicationMethod;
+  if (method.type !== "percentage" || method.targetType !== "order" || method.buyRulesMinQuantity != null) {
+    return { valid: false, percent: 0, reason: "unsupported" };
+  }
+  return { valid: true, percent: method.value };
+}
+var ruleContextRegistry = new Registry("ruleContext");
+function defineRuleContextProvider(id, provider, meta = {}) {
+  if (!id) throw new Error("defineRuleContextProvider: id is required");
+  if (!provider.attributes.length) {
+    throw new Error(`defineRuleContextProvider: "${id}" declares no attributes \u2014 a provider that contributes nothing cannot widen the vocabulary`);
+  }
+  const replacing = ruleContextRegistry.has(id);
+  for (const input of provider.attributes) {
+    registerRuleAttribute(
+      { ...input, path: input.path ?? `context.${input.key}` },
+      { meta: { source: "app", ...meta }, replace: replacing }
+    );
+  }
+  ruleContextRegistry.register(id, provider, {
+    description: `Rule context provider \u2014 contributes: ${provider.attributes.map((a) => a.key).join(", ")}`,
+    source: "app",
+    ...meta
+  });
+}
+function typeOk(value, fieldType) {
+  if (fieldType === "number") return typeof value === "number" && Number.isFinite(value);
+  if (fieldType === "boolean") return typeof value === "boolean";
+  return typeof value === "string";
+}
+function validateRuleContextResult(id, provider, result) {
+  const declared = new Map(provider.attributes.map((attribute) => [attribute.key, attribute]));
+  const validated = {};
+  for (const [key, value] of Object.entries(result)) {
+    const attribute = declared.get(key);
+    if (!attribute) {
+      throw new Error(
+        `Rule context provider "${id}" returned undeclared attribute "${key}". Declared attributes: ${[...declared.keys()].sort().join(", ")}`
+      );
+    }
+    if (value === null || value === void 0) continue;
+    const values = Array.isArray(value) ? value : [value];
+    for (const entry of values) {
+      if (!typeOk(entry, attribute.fieldType)) {
+        throw new Error(
+          `Rule context provider "${id}" returned ${JSON.stringify(entry)} for "${key}", which is declared as ${attribute.fieldType}`
+        );
+      }
+    }
+    validated[key] = value;
+  }
+  return validated;
+}
+async function buildRuleContext(cart) {
+  const context = {};
+  for (const entry of ruleContextRegistry.list()) {
+    const result = await entry.value.resolve(cart);
+    Object.assign(context, validateRuleContextResult(entry.id, entry.value, result));
+  }
+  return context;
+}
+function clearRuleContextProviders() {
+  ruleContextRegistry.clear();
+}
+
+export { APPLICATION_METHOD_ALLOCATIONS, APPLICATION_METHOD_TARGET_TYPES, APPLICATION_METHOD_TYPES, CORE_RULE_ATTRIBUTES, ITEM_PATH_PREFIX, PROMOTION_STATUSES, PROMOTION_TYPES, RULE_ATTRIBUTE_FIELD_TYPES, RULE_OPERATORS, actionsDiscountTotal, buildRuleContext, cartSubtotal, clearRuleAttributes, clearRuleContextProviders, computePromotionActions, defineRuleContextProvider, discountToPromotion, hasRuleAttribute, isItemScopedAttribute, listRuleAttributeKeys, listRuleAttributes, matchRuleValues, orderPromotions, previewCouponPercent, promotionGateReason, registerCoreRuleAttributes, registerRuleAttribute, resolveRuleAttribute, roundCents, ruleAttributeRegistry, ruleContextRegistry, rulesMatchCart, splitProportionally, storefrontDiscountToPromotion, validateRuleContextResult };
+//# sourceMappingURL=chunk-3GERSY5F.js.map
+//# sourceMappingURL=chunk-3GERSY5F.js.map