@blamejs/blamejs-shop 0.3.8 → 0.3.10

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.3.x
 
+- v0.3.10 (2026-05-30) — **Order discounts are split across lines for accurate partial refunds.** When an order carries a cart-level discount, the admin console now records how that discount split across the order's lines — proportional to each line's value — so a later partial refund of one line knows that line's discounted share rather than the whole-order amount. A new read-only Discount splits screen shows the per-line breakdown for an order. This is back-office bookkeeping recorded after the order is placed; it has no effect on what the shopper is charged, and an order with no discount records nothing. **Added:** *Per-line discount allocation + admin view* — An order that carried an automatic cart discount now gets a recorded breakdown of how that discount split across its lines — proportional to each line's subtotal, summing exactly to the discount. A read-only Discount splits admin screen shows the breakdown for an order. The recording runs after the order is placed and never affects the charged amount; an order with no discount records nothing.
+
+- v0.3.9 (2026-05-30) — **Automatic discounts now apply at checkout.** The automatic-discount rules you define in the admin console — an amount or percentage off a cart that meets a threshold — now reduce the order total at checkout. When a rule matches, the discount is applied (capped so it never exceeds the order subtotal) and shown in the quote the shopper pays; when no rule matches, or none are defined, the total is exactly as before, so a store that has not set up rules is unaffected. The admin screen for managing rules already shipped; this wires it through to the checkout quote and the charge. **Added:** *Automatic cart discounts at checkout* — When a cart matches a configured automatic-discount rule, the checkout reduces the order total by the rule's saving — capped to the order subtotal so the total is never negative — and the reduced amount is what the shopper is charged. With no matching rule, or no rules defined, the order total is unchanged, so the change stays invisible until you set rules up; any rule-engine error degrades to no discount rather than blocking checkout.
+
 - v0.3.8 (2026-05-30) — **Update the vendored blamejs runtime to v0.14.6.** Refreshes the vendored blamejs runtime from v0.14.5 to v0.14.6, a maintenance update. The createApp request-lifecycle security stack the shop composes — CSRF, fetch-metadata, body-parser, cookies, rate limiting — is unchanged in default behavior. v0.14.6 adds opt-in RFC 9457 problem+json and onDeny response hooks to the access-refusal middleware (defaults unchanged, so nothing the shop relies on shifts) and corrects a few internal export and bearer-scope paths. No operator action is required. **Changed:** *Vendored blamejs runtime updated to v0.14.6* — The pinned blamejs runtime moves from v0.14.5 to v0.14.6. The middleware the storefront and admin compose keeps its current default behavior; the release adds opt-in problem-details / onDeny response hooks to the refusal middleware and fixes internal export and bearer-scope paths. No behavior change for the shop.
 
 - v0.3.7 (2026-05-30) — **Shipping zones now apply at checkout.** The shipping zones you define in the admin console — per-region rates by destination, parcel weight, and order value — now drive the shipping options shown at checkout. When a cart's destination matches a zone, the shopper sees that zone's rates; when no zone matches, or none are defined, checkout falls back to the existing flat-rate table exactly as before, so a store that has not configured zones is entirely unaffected. A fully digital order is never quoted physical shipping. The admin screen for managing zones already shipped; this wires it through to the checkout quote. **Added:** *Zone-based shipping rates at checkout* — When a cart's destination matches a configured shipping zone, the checkout shipping quote uses that zone's rates — resolved by destination country and region, parcel weight, and order subtotal — instead of the flat-rate table. With no matching zone, or no zones defined, checkout returns the existing flat rates unchanged, so the change stays invisible until you set zones up; any lookup error degrades to the same flat fallback. A fully digital order (no shipping-requiring item) is never quoted physical shipping.

package/lib/admin.js

@@ -451,7 +451,7 @@ function mount(router, deps) {
   // `reports` is always present in the nav (read-only sales summary needs no
   // extra dep); its route mounts unconditionally and renders an unconfigured
   // notice when the salesReports primitive isn't wired.
-  var navAvailable = { returns: !!returns, reviews: !!reviews, productQa: !!productQa, subscriptions: !!deps.subscriptions, webhooks: !!deps.webhooks, collections: !!deps.collections, customers: !!deps.customers, giftcards: !!deps.giftcards, announcementBar: !!deps.announcementBar, customerSurveys: !!deps.customerSurveys, businessHours: !!deps.businessHours, taxRates: !!deps.taxRates, shippingZones: !!deps.shippingZones, autoDiscount: !!deps.autoDiscount, quantityDiscounts: !!deps.quantityDiscounts, pickLists: !!pickLists, salesTaxFilings: !!salesTaxFilings, shippingLabels: !!shippingLabels };
+  var navAvailable = { returns: !!returns, reviews: !!reviews, productQa: !!productQa, subscriptions: !!deps.subscriptions, webhooks: !!deps.webhooks, collections: !!deps.collections, customers: !!deps.customers, giftcards: !!deps.giftcards, announcementBar: !!deps.announcementBar, customerSurveys: !!deps.customerSurveys, businessHours: !!deps.businessHours, taxRates: !!deps.taxRates, shippingZones: !!deps.shippingZones, autoDiscount: !!deps.autoDiscount, discountAllocation: !!deps.discountAllocation, quantityDiscounts: !!deps.quantityDiscounts, pickLists: !!pickLists, salesTaxFilings: !!salesTaxFilings, shippingLabels: !!shippingLabels };
 
   try { b.audit.registerNamespace(AUDIT_NAMESPACE); } catch (_e) { /* idempotent */ }
 
@@ -3741,6 +3741,59 @@ function mount(router, deps) {
     ));
   }
 
+  // ---- discount allocations -------------------------------------------
+
+  // Read-only console for the per-line discount-allocation audit trail.
+  // When a placed order carried a cart-level discount, checkout records
+  // (post-commit) how that discount split across the order's lines, so a
+  // later partial refund knows each line's discounted share. Allocations
+  // are SYSTEM-WRITTEN — there's no create/edit here; the operator looks
+  // up an order id and reads back the recorded breakdown. Endpoints are
+  // omitted entirely when no discountAllocation primitive is wired.
+  var discountAllocation = deps.discountAllocation || null;
+  if (discountAllocation) {
+    // Look an order's recorded allocations up by id. Content-negotiates:
+    // bearer → JSON (the raw rows, unchanged for tooling); signed-in
+    // browser → the lookup form plus the rendered breakdown tables.
+    //
+    // The order id is a defensive request-shape reader — an empty / over-
+    // long / control-byte id makes allocationsForOrder throw a TypeError,
+    // which surfaces as an empty result + a notice, never a 500.
+    async function _lookupAllocations(orderId) {
+      if (typeof orderId !== "string" || orderId === "") return [];
+      try {
+        return await discountAllocation.allocationsForOrder(orderId);
+      } catch (e) {
+        if (e instanceof TypeError) return [];   // malformed id — treat as "nothing recorded"
+        throw e;
+      }
+    }
+
+    router.get("/admin/discount-allocation", _pageOrApi(true,
+      R(async function (req, res) {
+        var url = req.url ? new URL(req.url, "http://localhost") : null;
+        var orderId = (url && url.searchParams.get("order_id")) || "";
+        var rows = await _lookupAllocations(orderId);
+        _json(res, 200, { order_id: orderId, rows: rows });
+      }),
+      async function (req, res) {
+        var url = req.url ? new URL(req.url, "http://localhost") : null;
+        var orderId = (url && url.searchParams.get("order_id")) || "";
+        var rows = orderId ? await _lookupAllocations(orderId) : [];
+        var notice = (orderId && rows.length === 0)
+          ? "No discount allocations recorded for that order."
+          : null;
+        _sendHtml(res, 200, renderAdminDiscountAllocation({
+          shop_name:     deps.shop_name,
+          nav_available: navAvailable,
+          order_id:      orderId,
+          allocations:   rows,
+          notice:        notice,
+        }));
+      },
+    ));
+  }
+
   // ---- announcements --------------------------------------------------
   // Sitewide promo/notice strip. Content-negotiated like the other console
   // screens: bearer → the JSON contract; signed-in browser → the HTML
@@ -6135,6 +6188,7 @@ var ADMIN_NAV_ITEMS = [
   { key: "subscriptions", href: "/admin/subscription-plans", label: "Subscriptions", requires: "subscriptions" },
   { key: "collections",  href: "/admin/collections",  label: "Collections",  requires: "collections" },
   { key: "discounts",    href: "/admin/discounts",    label: "Discounts",    requires: "autoDiscount" },
+  { key: "discount-allocation", href: "/admin/discount-allocation", label: "Discount splits", requires: "discountAllocation" },
   { key: "quantity-discounts", href: "/admin/quantity-discounts", label: "Quantity breaks", requires: "quantityDiscounts" },
   { key: "tax",          href: "/admin/tax-rates",    label: "Tax",          requires: "taxRates" },
   { key: "tax-filings",  href: "/admin/tax-filings",  label: "Tax filings",  requires: "salesTaxFilings" },
@@ -8674,6 +8728,60 @@ function renderAdminCollections(opts) {
   return _renderAdminShell(opts.shop_name, "Collections", bodyHtml, "collections", opts.nav_available);
 }
 
+// Read-only view of the per-line discount-allocation audit trail for one
+// order. The operator looks an order up by id; each recorded allocation
+// renders as a header (source, kind, total, recorded-at) plus a table of
+// the per-line breakdown. Allocations are system-written by checkout —
+// there's no create/edit affordance here. Amounts are exact minor-unit
+// integers (the audit row carries no currency; the figures are the same
+// integers the refund math reads back), so the operator sees the precise
+// recorded split rather than a rounded display value.
+function renderAdminDiscountAllocation(opts) {
+  opts = opts || {};
+  var orderId = typeof opts.order_id === "string" ? opts.order_id : "";
+  var allocations = opts.allocations || [];
+  var notice = opts.notice ? "<div class=\"banner banner--warn\">" + _htmlEscape(opts.notice) + "</div>" : "";
+
+  var lookupForm =
+    "<div class=\"panel mw-40\">" +
+      "<h3 class=\"subhead\">Look up an order</h3>" +
+      "<p class=\"meta\">When an order carried a cart-level discount, the split across its lines is recorded here for refund precision. Enter an order id to see its recorded allocations.</p>" +
+      "<form method=\"get\" action=\"/admin/discount-allocation\">" +
+        _setupField("Order id", "order_id", orderId, "text", "The order's id (shown on the order detail page).", " maxlength=\"200\"") +
+        "<div class=\"actions-row\"><button class=\"btn\" type=\"submit\">Look up</button></div>" +
+      "</form>" +
+    "</div>";
+
+  var results = "";
+  if (allocations.length) {
+    results = allocations.map(function (a) {
+      var breakdown = Array.isArray(a.breakdown) ? a.breakdown : [];
+      var lineRows = breakdown.map(function (l) {
+        return "<tr>" +
+          "<td><code class=\"order-id\">" + _htmlEscape(String(l.line_id)) + "</code></td>" +
+          "<td class=\"num\">" + _htmlEscape(String(l.allocated_minor)) + "</td>" +
+          "<td class=\"num\">" + _htmlEscape(String(l.remaining_minor)) + "</td>" +
+        "</tr>";
+      }).join("");
+      var lineTable = breakdown.length
+        ? "<table><thead><tr><th scope=\"col\">Line</th><th scope=\"col\" class=\"num\">Allocated (minor)</th><th scope=\"col\" class=\"num\">Remaining (minor)</th></tr></thead><tbody>" + lineRows + "</tbody></table>"
+        : "<p class=\"empty\">This allocation has no recorded lines.</p>";
+      return "<div class=\"panel mt\">" +
+        "<h3 class=\"subhead\">" + _htmlEscape(a.source || "—") + "</h3>" +
+        "<p class=\"meta\">" +
+          "Split: <strong>" + _htmlEscape(a.kind || "—") + "</strong>" +
+          " &middot; Total: <strong>" + _htmlEscape(String(a.total_minor)) + "</strong> minor units" +
+          " &middot; Recorded: " + _htmlEscape(_fmtDate(a.applied_at)) +
+        "</p>" +
+        lineTable +
+      "</div>";
+    }).join("");
+  }
+
+  var bodyHtml = "<section><h2>Discount splits</h2>" + notice + lookupForm + results + "</section>";
+  return _renderAdminShell(opts.shop_name, "Discount splits", bodyHtml, "discount-allocation", opts.nav_available);
+}
+
 // A <datetime-local> form value → epoch ms (integer) for the lib's
 // starts_at/expires_at, or null when blank/unparseable (open-ended). The
 // announcement primitive validates the result; a blank schedule field just
@@ -9564,6 +9672,7 @@ module.exports = {
   renderAdminShipping:     renderAdminShipping,
   renderAdminShippingZone: renderAdminShippingZone,
   renderAdminDiscounts:    renderAdminDiscounts,
+  renderAdminDiscountAllocation: renderAdminDiscountAllocation,
   renderAdminQuantityDiscounts: renderAdminQuantityDiscounts,
   renderAdminQuantityDiscount:  renderAdminQuantityDiscount,
   renderAdminConfirm:      renderAdminConfirm,

package/lib/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.8",
+  "version": "0.3.10",
   "assets": {
     "css/admin.css": {
       "integrity": "sha384-1SIn6oAf1DjECbRfKENZasdKHJiywGdXR58wn0hsFGcdVHzUmvfgMkEz5ANIAZJ3",

package/lib/checkout.js

@@ -146,6 +146,27 @@ function create(deps) {
   // server-authoritative computation the cart page renders, so the
   // "review your order" subtotal and the charged amount agree.
   var quantityDiscounts = deps.quantityDiscounts || null;
+  // Optional automatic-discount engine. When wired, the quote consults
+  // every operator-authored auto-discount rule against the resolved
+  // cart and reduces the subtotal by the matched savings (clamped to
+  // [0, subtotal] so a rule can never drive the order negative or
+  // charge more than the cart is worth). Disabled when absent — the
+  // discount is zero and every total is identical to the un-wired
+  // flow, so production stays unchanged until a rule is defined. Only
+  // subtotal-reducing savings feed `discount_minor`; a `free_shipping`
+  // rule's savings are a shipping concern and are left to the shipping
+  // primitive, not folded into the subtotal discount here.
+  var autoDiscount  = deps.autoDiscount || null;
+  // Optional discount-allocation recorder. When wired, a placed order
+  // that carried a cart-level discount gets a per-line breakdown of how
+  // that discount split across the order lines, recorded as a back-office
+  // audit row so a later partial refund knows each line's discounted
+  // share. POST-COMMIT + drop-silent: it runs after the order exists, in
+  // its own try/catch, so a recording failure can never fail, reverse, or
+  // change the charge of a placed order. No discount -> nothing recorded.
+  // Disabled when absent — the buy path is byte-identical to the un-wired
+  // flow.
+  var discountAllocation = deps.discountAllocation || null;
 
   // Reprice a list of cart lines through the quantity-discount engine.
   // Returns a shallow copy with `unit_amount_minor` overwritten by the
@@ -179,6 +200,72 @@ function create(deps) {
     return out;
   }
 
+  // Resolve the automatic-discount effect for a priced cart. Builds
+  // the engine's cart shape from the resolved lines + subtotal, asks
+  // the engine which operator-authored rules apply, and returns the
+  // subtotal-reducing savings (clamped to [0, subtotal]) plus the
+  // per-rule breakdown the post-commit recorder replays.
+  //
+  // FALLBACK (zero regression): no engine wired, a non-finite or
+  // negative aggregate, an empty result, or ANY throw collapses to
+  // `{ discount_minor: 0, applied: [] }` — byte-identical to the
+  // un-wired flow. The engine is consulted but never trusted to keep
+  // the buy path alive.
+  //
+  // PAYMENT SAFETY: the returned discount is clamped to
+  // [0, subtotalMinor] so it can never be negative and never exceeds
+  // the subtotal — the order total can therefore never go negative,
+  // and a customer can never be charged less than zero or credited
+  // more than the cart is worth.
+  async function _resolveAutoDiscount(lines, subtotalMinor, customerId) {
+    if (!autoDiscount || typeof autoDiscount.evaluate !== "function") {
+      return { discount_minor: 0, applied: [] };
+    }
+    try {
+      var evalLines = [];
+      for (var i = 0; i < lines.length; i += 1) {
+        var l = lines[i];
+        evalLines.push({
+          sku:              l.sku,
+          quantity:         l.qty,
+          unit_price_minor: l.unit_amount_minor,
+        });
+      }
+      var res = await autoDiscount.evaluate({
+        cart: {
+          subtotal_minor: subtotalMinor,
+          lines:          evalLines,
+        },
+        customer_id: customerId || undefined,
+      });
+      var appliedRaw = res && Array.isArray(res.applied) ? res.applied : [];
+      var total   = 0;
+      var applied = [];
+      for (var j = 0; j < appliedRaw.length; j += 1) {
+        var entry = appliedRaw[j];
+        // A `free_shipping` rule's savings are a shipping reduction,
+        // not a subtotal discount — excluded so the subtotal-level
+        // `discount_minor` stays a pure subtotal reduction (the
+        // shipping primitive owns the shipping side).
+        if (!entry || entry.value_kind === "free_shipping") continue;
+        var s = entry.savings_minor;
+        if (!Number.isInteger(s) || s <= 0) continue;
+        total += s;
+        applied.push({ rule_slug: entry.rule_slug, savings_minor: s });
+      }
+      if (!Number.isFinite(total) || total <= 0) {
+        return { discount_minor: 0, applied: [] };
+      }
+      // Clamp to the subtotal floor: the discount can reduce the
+      // subtotal to zero but never past it.
+      if (total > subtotalMinor) total = subtotalMinor;
+      return { discount_minor: total, applied: applied };
+    } catch (_e) {
+      // Any engine failure -> no discount, never a 5xx on the buy path.
+      return { discount_minor: 0, applied: [] };
+    }
+  }
+
   // Validate a gift-card code against a priced quote: the card exists,
   // is active, not expired, and matches the order currency. Returns
   // the credit to apply (capped at the grand total so an order total
@@ -336,6 +423,99 @@ function create(deps) {
     });
   }
 
+  // Record each applied auto-discount rule against a committed order
+  // so the engine's redemption counter + event log reflect the use.
+  // Best-effort / drop-silent: the customer has already been charged
+  // (or the order is otherwise placed) by the time this runs, so a
+  // recording failure must NEVER fail or reverse the order. Each
+  // record is isolated in its own try/catch so one bad row can't stop
+  // the rest. No-op when the engine isn't wired or nothing applied.
+  async function _recordAutoDiscounts(quote, orderId, customerId) {
+    if (!autoDiscount || typeof autoDiscount.recordApplication !== "function") return;
+    var applied = quote && Array.isArray(quote.auto_discounts) ? quote.auto_discounts : [];
+    for (var i = 0; i < applied.length; i += 1) {
+      var a = applied[i];
+      if (!a || !a.rule_slug) continue;
+      try {
+        await autoDiscount.recordApplication({
+          rule_slug:     a.rule_slug,
+          order_id:      orderId,
+          savings_minor: a.savings_minor,
+          customer_id:   customerId || undefined,
+        });
+      } catch (_e) {
+        // drop-silent — by design: the order is already placed; a
+        // failed redemption record must not surface to the buyer.
+      }
+    }
+  }
+
+  // Record HOW a cart-level order discount split across the order lines,
+  // for accounting + partial-refund precision. The recorded breakdown's
+  // per-line `allocated_minor` values sum exactly to the discount, so a
+  // later partial refund of one line can remove that line's share rather
+  // than the whole-order amount.
+  //
+  // POST-COMMIT + drop-silent — by design: the order is already placed
+  // (and, in the charged path, the PaymentIntent already exists) by the
+  // time this runs. The entire body is wrapped in one try/catch so a
+  // recording failure (bad input, DB error, an unmigrated table) can
+  // NEVER fail, reverse, or change the charge of a placed order. This is
+  // pure back-office bookkeeping with zero impact on the charged amount.
+  //
+  // No-op when: the recorder isn't wired, the order carried no discount
+  // (discount_minor <= 0), or the order has no lines to split across.
+  // The default split is `proportional` (by line subtotal) — the
+  // operator-readable "each line absorbs its share of the savings"
+  // distribution.
+  async function _recordDiscountAllocation(quote, orderLines, orderId) {
+    if (!discountAllocation ||
+        typeof discountAllocation.allocate !== "function" ||
+        typeof discountAllocation.recordAllocation !== "function") return;
+    try {
+      var discount = quote && quote.totals ? quote.totals.discount_minor : 0;
+      if (!Number.isInteger(discount) || discount <= 0) return;   // no discount -> record nothing
+      if (!Array.isArray(orderLines) || orderLines.length === 0) return;
+
+      // Build the allocate() line shape from the placed order lines. The
+      // line_id is the PERSISTED order-line id, so a later partial refund —
+      // which operates on order lines — can apply the breakdown directly
+      // without re-mapping by (variant, sku). The per-line subtotal is
+      // unit_amount_minor * qty — the same per-line
+      // figure pricing.subtotal summed into quote.totals.subtotal_minor,
+      // so the discount (clamped to <= subtotal upstream) never exceeds
+      // the total line weight.
+      var lines = [];
+      for (var i = 0; i < orderLines.length; i += 1) {
+        var l = orderLines[i];
+        var lineId = l.line_id != null ? l.line_id : l.id;
+        if (lineId == null) return;                                 // no stable id to key the breakdown on
+        lines.push({
+          line_id:        String(lineId),
+          subtotal_minor: l.unit_amount_minor * l.qty,
+          quantity:       l.qty,
+        });
+      }
+
+      var breakdown = discountAllocation.allocate({
+        lines:          lines,
+        discount_minor: discount,
+        kind:           "proportional",
+      });
+      await discountAllocation.recordAllocation({
+        order_id:        orderId,
+        discount_source: "auto_discount",
+        kind:            "proportional",
+        breakdown:       breakdown,
+        total_minor:     discount,
+      });
+    } catch (_e) {
+      // drop-silent — by design: the order is already placed; a failed
+      // allocation record is back-office bookkeeping and must never
+      // surface to the buyer or affect the charge.
+    }
+  }
+
   // Compose a quote from a cart + ship-to + (optional) selected
   // shipping service. Pure read — no DB writes.
   async function _buildQuote(input) {
@@ -390,10 +570,18 @@ function create(deps) {
     }
 
     var shippingMinor = selected ? selected.amount_minor : 0;
+
+    // Automatic discounts: consult the operator-authored rule engine
+    // (when wired) for the subtotal reduction this cart earns. The
+    // resolver clamps the result to [0, subtotal] and falls back to 0
+    // on any failure, so the total math below is identical to the
+    // un-wired flow whenever no rule applies.
+    var autoDisc = await _resolveAutoDiscount(lines, sub.amount_minor, c.customer_id || null);
+
     var totals = pricing.totals(c, lines, {
       tax_minor:      taxRow.tax_minor,
       shipping_minor: shippingMinor,
-      discount_minor: 0,
+      discount_minor: autoDisc.discount_minor,
     });
 
     return {
@@ -405,6 +593,10 @@ function create(deps) {
       shipping_rates:    ratesRow.services,
       selected_shipping: selected,
       totals:            totals,
+      // Per-rule breakdown that fed `totals.discount_minor`, replayed
+      // by confirm()'s post-commit recorder. Empty when no rule
+      // applied (or no engine wired).
+      auto_discounts:    autoDisc.applied,
     };
   }
 
@@ -499,6 +691,14 @@ function create(deps) {
         });
         if (gc) await _redeemGiftCard(gc, paidOrder.id);
         if (loy) await _redeemLoyalty(loy, loyaltyCustomerId, paidOrder.id);
+        // Best-effort: record the auto-discount redemptions against the
+        // placed order. Runs post-commit so a recording failure can't
+        // reverse an order that's already paid.
+        await _recordAutoDiscounts(quote, paidOrder.id, cartRow.customer_id || null);
+        // Best-effort: record how the cart-level discount split across the
+        // order lines (accounting + refund precision). Post-commit +
+        // drop-silent — no impact on the already-settled order.
+        await _recordDiscountAllocation(quote, paidOrder.lines, paidOrder.id);
         await cart.setStatus(quote.cart_id, "converted");
         var settled = await order.transition(paidOrder.id, "mark_paid", {
           reason: loy && !gc ? "loyalty:full" : "gift_card:full",
@@ -552,6 +752,15 @@ function create(deps) {
       // guard.
       if (gc) await _redeemGiftCard(gc, createdOrder.id);
       if (loy) await _redeemLoyalty(loy, loyaltyCustomerId, createdOrder.id);
+      // Best-effort: record the auto-discount redemptions against the
+      // placed order. Runs post-commit so a recording failure can't
+      // reverse or fail an order whose PaymentIntent already exists.
+      await _recordAutoDiscounts(quote, createdOrder.id, cartRow.customer_id || null);
+      // Best-effort: record how the cart-level discount split across the
+      // order lines (accounting + refund precision). Post-commit +
+      // drop-silent — the PaymentIntent already exists; this never
+      // changes the charged amount.
+      await _recordDiscountAllocation(quote, createdOrder.lines, createdOrder.id);
 
       // Mark the cart converted so a refresh of the storefront
       // doesn't accidentally re-quote the same cart.

package/lib/storefront.js

@@ -7139,7 +7139,7 @@ function mount(router, deps) {
 
   // Compute the cart/checkout totals the shopper sees BEFORE paying.
   // Composes the SAME tax + shipping primitives the charge runs through
-  // (via checkout.quote, which prices tax against the post-discount
+  // (via checkout.quote, which prices tax against the pre-discount
   // subtotal + picks shipping rates for the destination), so the
   // displayed grand total agrees with what Stripe is later asked to
   // charge for that destination. Returns:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {