@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.69

package/src/nodes/cart/cart-add-item.ts

@@ -1,3 +1,4 @@
+import { CartCurrency } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
 import {
   COMMERCE_TRACKING_HELPER_SOURCE,
@@ -10,6 +11,11 @@ import {
 // module scope. Declaring the name emits nothing and leaves a bare identifier
 // that the appended helper source defines. See `commerce-tracking.ts`.
 declare function trackCommerceStep(step: { name: string; detail?: Record<string, unknown> }): void
+// Same, for the cart-currency rule (`CartCurrency` in teleport-shared).
+declare function __ccCurrencyRefusal(input: {
+  lines: unknown[]
+  currency: unknown
+}): { added: false; reason: string; message: string } | null
 
 async function cart_add_item(config: any) {
   const productId = config.productId
@@ -30,6 +36,120 @@ async function cart_add_item(config: any) {
   const discountType = config.discountType || null
   const discountValue = config.discountValue != null ? Number(config.discountValue) : null
   const discountAmount = config.discountAmount != null ? Number(config.discountAmount) : 0
+  // What the discount engine prices the line by: its category ids INCLUDING
+  // ancestors (`category_filter_ids`), and whether the product IS a gift card
+  // — never discounted, and a cart holding one cannot be paid with one. The
+  // workflow may hand either the parsed array or the raw JSON column, and a
+  // config boolean arrives as the string 'true'; anything unreadable is
+  // "no categories" / "not a gift card", never a thrown add-to-cart.
+  let categoryIds: string[] = []
+  try {
+    let rawCategories = config.categoryIds
+    if (typeof rawCategories === 'string' && rawCategories !== '') {
+      rawCategories = JSON.parse(rawCategories)
+    }
+    if (Array.isArray(rawCategories)) {
+      categoryIds = rawCategories
+        .filter((entry: unknown) => entry !== null && entry !== undefined && entry !== '')
+        .map((entry: unknown) => String(entry))
+    }
+  } catch {
+    categoryIds = []
+  }
+  const readFlag = (value: unknown): boolean =>
+    value === true ||
+    value === 1 ||
+    (typeof value === 'string' && ['true', 't', '1', 'yes'].indexOf(value.toLowerCase()) !== -1)
+  const isGiftCard = readFlag(config.isGiftCard)
+  // The line's kind, from the product row the workflow fetched: a subscription
+  // is billed by the provider every interval and checks out alone at quantity
+  // one; a gift card is issued by email once paid; a digital line is delivered
+  // from the order page; anything else ships. One order holds ONE kind, so the
+  // cart does too — a line of another kind is refused here, before anything is
+  // written, and the workflow toasts why. One order is also charged in ONE
+  // currency, so a line priced in another currency is refused the same way.
+  const isRecurring = readFlag(config.isRecurring)
+  const isDigital = readFlag(config.isDigital)
+  const recurringInterval = isRecurring ? String(config.recurringInterval || 'month') : null
+  const recurringIntervalCount = isRecurring
+    ? Math.max(1, Math.floor(Number(config.recurringIntervalCount)) || 1)
+    : null
+  const trialDays = isRecurring ? Math.max(0, Math.floor(Number(config.trialDays)) || 0) : null
+  const kindOf = (line: any): 'subscription' | 'gift-card' | 'digital' | 'physical' =>
+    readFlag(line && line.isRecurring)
+      ? 'subscription'
+      : readFlag(line && line.isGiftCard)
+      ? 'gift-card'
+      : readFlag(line && line.isDigital)
+      ? 'digital'
+      : 'physical'
+  const KIND_LABELS = {
+    subscription: 'Subscriptions',
+    'gift-card': 'Gift cards',
+    digital: 'Digital products',
+    physical: 'Physical products',
+  }
+  const lineKind = kindOf({ isRecurring, isGiftCard, isDigital })
+  const refuse = (
+    reason: 'mixed-cart' | 'mixed-currency' | 'one-subscription' | 'options-invalid',
+    message: string
+  ) => ({
+    added: false,
+    reason,
+    message,
+  })
+
+  // The options the shopper chose, priced by the add-to-cart workflow:
+  // `configuration` is the canonical JSON of the answers and `configurationKey`
+  // its hash. A line is identified by product, variant AND configuration, so
+  // two configurations of one product are two lines. `price` already includes
+  // the options' surcharge (`configurationPriceDelta`, NET per unit) on top of
+  // `basePrice`, the charged base, so every total downstream reads `price`
+  // unchanged. A line without options carries none of these fields.
+  const rawConfiguration = config.configuration
+  const configuration = Array.isArray(rawConfiguration)
+    ? rawConfiguration.length > 0
+      ? JSON.stringify(rawConfiguration)
+      : ''
+    : typeof rawConfiguration === 'string'
+    ? rawConfiguration.trim()
+    : ''
+  const configurationKey = configuration
+    ? String(config.configurationKey == null ? '' : config.configurationKey)
+        .trim()
+        .slice(0, 64)
+    : ''
+  const configurationPriceDelta =
+    config.configurationPriceDelta == null || config.configurationPriceDelta === ''
+      ? 0
+      : Number(config.configurationPriceDelta)
+  // The same 8000-character cap the checkout enforces, so a line the checkout
+  // would refuse never reaches the cart.
+  if (configuration.length > 8000) {
+    return refuse('options-invalid', 'Your personalisation is too long. Please shorten it.')
+  }
+  if (
+    configuration &&
+    (!configurationKey || !isFinite(configurationPriceDelta) || configurationPriceDelta < 0)
+  ) {
+    return refuse(
+      'options-invalid',
+      'Some of the options you chose are no longer available. Please review them.'
+    )
+  }
+  const statedBasePrice =
+    config.basePrice == null || config.basePrice === '' ? NaN : Number(config.basePrice)
+  const lineOptions = configurationKey
+    ? {
+        configuration,
+        configurationKey,
+        configurationLabel: String(config.configurationLabel || '').slice(0, 500),
+        configurationPriceDelta,
+        basePrice: isFinite(statedBasePrice)
+          ? statedBasePrice
+          : Math.round((price - configurationPriceDelta) * 100) / 100,
+      }
+    : null
 
   // Per-product cap is published by `EcommerceProvider` to localStorage so
   // workflow handlers (which run outside React) can enforce the same limit
@@ -49,11 +169,44 @@ async function cart_add_item(config: any) {
     const raw = localStorage.getItem('workflow_cart')
     const cart: any[] = raw ? JSON.parse(raw) : []
 
+    // The key is a lookup hint, not an identity: a configured line is the same
+    // line only when its configuration is identical too.
     const existingIndex = cart.findIndex(
       (item: any) =>
-        item.productId === productId && (item.variantId || null) === (variantId || null)
+        item.productId === productId &&
+        (item.variantId || null) === (variantId || null) &&
+        String(item.configurationKey || '') === configurationKey &&
+        (!configurationKey || item.configuration === configuration)
     )
 
+    // A subscription already in the cart is the one unit it will ever be.
+    if (existingIndex >= 0 && (isRecurring || kindOf(cart[existingIndex]) === 'subscription')) {
+      return refuse(
+        'one-subscription',
+        'Subscriptions are checked out on their own. Finish or empty your current cart first.'
+      )
+    }
+    const otherLines = cart.filter((_line: any, index: number) => index !== existingIndex)
+    if (otherLines.length > 0) {
+      if (isRecurring || kindOf(otherLines[0]) === 'subscription') {
+        return refuse(
+          'one-subscription',
+          'Subscriptions are checked out on their own. Finish or empty your current cart first.'
+        )
+      }
+      if (kindOf(otherLines[0]) !== lineKind) {
+        return refuse(
+          'mixed-cart',
+          KIND_LABELS[lineKind] +
+            ' need a separate order. Complete your current order or remove the other items from your cart first.'
+        )
+      }
+      const currencyRefusal = __ccCurrencyRefusal({ lines: otherLines, currency })
+      if (currencyRefusal) {
+        return refuse('mixed-currency', currencyRefusal.message)
+      }
+    }
+
     if (existingIndex >= 0) {
       let nextQty = (Number(cart[existingIndex].quantity) || 0) + quantity
       if (maxQty !== null && nextQty > maxQty) {
@@ -86,6 +239,21 @@ async function cart_add_item(config: any) {
       cart[existingIndex].discountType = discountType
       cart[existingIndex].discountValue = discountValue
       cart[existingIndex].discountAmount = discountAmount
+      // Same rule: a product moved to another category, or turned into a gift
+      // card, must re-price on the next add — the empty list and `false` are
+      // the values that say "none".
+      cart[existingIndex].categoryIds = categoryIds
+      cart[existingIndex].isGiftCard = isGiftCard
+      cart[existingIndex].isRecurring = isRecurring
+      cart[existingIndex].recurringInterval = recurringInterval
+      cart[existingIndex].recurringIntervalCount = recurringIntervalCount
+      cart[existingIndex].trialDays = trialDays
+      cart[existingIndex].isDigital = isDigital
+      // The same answers can carry a new label or surcharge (an option renamed
+      // or repriced since the line was added).
+      if (lineOptions) {
+        Object.assign(cart[existingIndex], lineOptions)
+      }
       localStorage.setItem('workflow_cart', JSON.stringify(cart))
       if (typeof window !== 'undefined') {
         window.dispatchEvent(new CustomEvent('teleport:cart-changed'))
@@ -100,13 +268,18 @@ async function cart_add_item(config: any) {
           items: [{ item_id: productId, item_name: name, price, quantity }],
         },
       })
-      return {
+      const updated: any = {
         id: cart[existingIndex].id,
         productId,
         quantity: cart[existingIndex].quantity,
+        added: true,
+      }
+      if (lineOptions) {
+        updated.configurationKey = configurationKey
       }
+      return updated
     } else {
-      let initialQty = quantity
+      let initialQty = isRecurring ? 1 : quantity
       if (maxQty !== null && initialQty > maxQty) {
         initialQty = maxQty
       }
@@ -125,6 +298,16 @@ async function cart_add_item(config: any) {
         discountType,
         discountValue,
         discountAmount,
+        categoryIds,
+        isGiftCard,
+        isRecurring,
+        recurringInterval,
+        recurringIntervalCount,
+        trialDays,
+        isDigital,
+      }
+      if (lineOptions) {
+        Object.assign(newItem, lineOptions)
       }
       cart.push(newItem)
       localStorage.setItem('workflow_cart', JSON.stringify(cart))
@@ -139,7 +322,11 @@ async function cart_add_item(config: any) {
           items: [{ item_id: productId, item_name: name, price, quantity: initialQty }],
         },
       })
-      return { id: newItem.id, productId, quantity: initialQty }
+      const added: any = { id: newItem.id, productId, quantity: initialQty, added: true }
+      if (lineOptions) {
+        added.configurationKey = configurationKey
+      }
+      return added
     }
   } catch (err: unknown) {
     return { success: false, error: (err as Error).message }
@@ -149,12 +336,16 @@ export const cartAddItem: NodeHandlerGenerator = {
   nodeType: 'cart-add-item',
   executionEnv: 'client',
   generateHandler(): string {
-    // The helper is concatenated rather than imported: the handler ships as a
-    // serialized function body with no module scope. It is a string literal
-    // rather than a `.toString()` so a consumer's minifier cannot strip its
-    // declaration name. See `commerce-tracking.ts`.
+    // The helpers are concatenated rather than imported: the handler ships as
+    // a serialized function body with no module scope. They are string
+    // literals rather than a `.toString()` so a consumer's minifier cannot
+    // strip their declaration names. See `commerce-tracking.ts`.
     return assertHandlerHasNoModuleRefs(
-      handlerToString(cart_add_item) + '\n' + COMMERCE_TRACKING_HELPER_SOURCE,
+      handlerToString(cart_add_item) +
+        '\n' +
+        COMMERCE_TRACKING_HELPER_SOURCE +
+        '\n' +
+        CartCurrency.generateCartCurrencyHelperCode(),
       'cart-add-item'
     )
   },

package/src/nodes/cart/cart-clear.ts

@@ -43,6 +43,15 @@ async function cart_clear() {
         // key — a serialized handler cannot import
         // `RegionalPricing.SHIPPING_RATE_STORAGE_KEY`.
         localStorage.removeItem('workflow_shipping_rate')
+        // And the gift card applied to it: its balance belongs to the shopper,
+        // not to this cart, so the next order asks for the code again rather
+        // than silently spending what is left. Literal key — a serialized
+        // handler cannot import `DiscountEngine.GIFT_CARD_STORAGE_KEY`.
+        localStorage.removeItem('workflow_gift_card')
+        // And the discount set chosen for it: the next order's choice is made
+        // over the next order's discounts. Literal key — a serialized handler
+        // cannot import `DiscountEngine.DISCOUNT_CHOICE_STORAGE_KEY`.
+        localStorage.removeItem('workflow_discount_choice')
         const sessionId = localStorage.getItem('workflow_cart_session_id') || null
         fetch('/api/cart/sync', {
           method: 'POST',
@@ -55,6 +64,8 @@ async function cart_clear() {
       window.dispatchEvent(new CustomEvent('teleport:cart-changed'))
       window.dispatchEvent(new CustomEvent('teleport:voucher-changed'))
       window.dispatchEvent(new CustomEvent('teleport:shipping-rate-changed'))
+      window.dispatchEvent(new CustomEvent('teleport:gift-card-changed'))
+      window.dispatchEvent(new CustomEvent('teleport:discount-choice-changed'))
     }
     return { success: true }
   } catch (err: unknown) {

package/src/nodes/cart/cart-get-total.ts

@@ -1,13 +1,21 @@
-import { RegionalPricing } from '@teleporthq/teleport-shared'
+import { CartCurrency, DiscountEngine, RegionalPricing } from '@teleporthq/teleport-shared'
 import { NodeHandlerGenerator, handlerToString } from '../types'
 
 // AMBIENT, not imported: the handler ships as a serialized function with no
-// module scope, and the shared regional-pricing helpers are spliced into its
-// body by `generateHandler` below. See `commerce-tracking.ts` for why an import
-// would compile to a module reference that throws in the browser.
+// module scope, and the shared regional-pricing and discount-engine helpers
+// are spliced into its body by `generateHandler` below. See
+// `commerce-tracking.ts` for why an import would compile to a module reference
+// that throws in the browser.
 declare function __rpQuote(input: Record<string, unknown>): any
 declare function __rpNormalizeConfig(rows: unknown): Record<string, unknown>
 declare function __rpReadCheckoutDestination(countryCodes: unknown): Record<string, string> | null
+declare function __deNormalizeRule(row: unknown, source: string): Record<string, unknown> | null
+declare function __deLinesFromCart(items: unknown): unknown[]
+declare function __deResolve(input: Record<string, unknown>): any
+declare function __deTender(input: Record<string, unknown>): { applied: number; amountDue: number }
+declare function __deBool(value: unknown, fallback: boolean): boolean
+declare function __ccCode(value: unknown): string
+declare function __ccCartCurrency(lines: unknown): string
 
 async function cart_get_total() {
   try {
@@ -55,6 +63,39 @@ async function cart_get_total() {
     // provider priced the page from, mirrored for exactly this moment. Present
     // only on a store with regional pricing.
     let regionalSnapshot: Record<string, any> | null = null
+    // The discount engine's rule feed (`{ enabled, automaticDiscounts, rows,
+    // customer }`), the shopper context the checkout page-load workflow wrote
+    // (`{ isFirstOrder, resolvedAt }`) and the gift-card feature
+    // (`{ enabled, currency }`), all mirrored by the provider for exactly this
+    // moment. Each is absent on a store without the feature, and on a
+    // storefront exported before it existed — which correctly resolves to the
+    // flat voucher rule and no tender. Whether a stored voucher is honoured
+    // at all travels the same way; absent means no objection.
+    let discountsSnapshot: Record<string, any> | null = null
+    let customerSnapshot: Record<string, any> | null = null
+    let giftCardsSnapshot: Record<string, any> | null = null
+    // Whether recurring products can be sold and by which providers — mirrored
+    // at export, so the place-order script reads the CURRENT capability rather
+    // than the list baked into it when the checkout page was built.
+    let subscriptionsSnapshot: Record<string, any> | null = null
+    // Which cart kinds each provider may be paid for (see the storefront context).
+    let paymentKindsSnapshot: Record<string, unknown> | null = null
+    let vouchersEnabled = true
+    // The gift card the shopper applied — `{ id, last4, balance, currency }`
+    // as the Apply Gift Card workflow left it. The place-order workflow uses
+    // ONLY its `id`, to re-read and debit the row; the balance here decides
+    // what the summary showed, never what is charged.
+    let storedGiftCard: Record<string, any> | null = null
+    // The set of discounts the shopper chose when several could apply but not
+    // together — the checkout's chooser writes it; unknown reads as "the set
+    // that saves the most". Literal key: a serialized handler cannot import
+    // `DiscountEngine.DISCOUNT_CHOICE_STORAGE_KEY`.
+    let discountChoice = ''
+    try {
+      discountChoice = localStorage.getItem('workflow_discount_choice') || ''
+    } catch (_choiceErr) {
+      discountChoice = ''
+    }
     try {
       const voucherRaw = localStorage.getItem('workflow_voucher')
       if (voucherRaw) {
@@ -97,10 +138,41 @@ async function cart_get_total() {
           const parsedRate = Number(parsed.taxConfig.storefrontTaxRate)
           storefrontTaxRate = isFinite(parsedRate) && parsedRate > 0 ? parsedRate : 0
         }
+        if (parsed && typeof parsed === 'object') {
+          if (parsed.discounts && typeof parsed.discounts === 'object') {
+            discountsSnapshot = parsed.discounts
+          }
+          if (parsed.customer && typeof parsed.customer === 'object') {
+            customerSnapshot = parsed.customer
+          }
+          if (parsed.giftCards && typeof parsed.giftCards === 'object') {
+            giftCardsSnapshot = parsed.giftCards
+          }
+          if (typeof parsed.vouchersEnabled === 'boolean') {
+            vouchersEnabled = parsed.vouchersEnabled
+          }
+          if (parsed.subscriptions && typeof parsed.subscriptions === 'object') {
+            subscriptionsSnapshot = parsed.subscriptions
+          }
+          if (parsed.paymentKinds && typeof parsed.paymentKinds === 'object') {
+            paymentKindsSnapshot = parsed.paymentKinds
+          }
+        }
       }
     } catch (_settingsErr) {
       /* ignore — fall back to absent deliveryConfig / no tax */
     }
+    try {
+      const giftCardRaw = localStorage.getItem('workflow_gift_card')
+      if (giftCardRaw) {
+        const parsedGiftCard = JSON.parse(giftCardRaw)
+        if (parsedGiftCard && typeof parsedGiftCard === 'object' && parsedGiftCard.id) {
+          storedGiftCard = parsedGiftCard
+        }
+      }
+    } catch (_giftCardErr) {
+      /* ignore — malformed or unavailable storage reads as no gift card */
+    }
 
     const round = (n: number) => Math.round(n * 100) / 100
     // Per-UNIT rounding, matching EcommerceProvider exactly, so the amount the
@@ -133,11 +205,35 @@ async function cart_get_total() {
 
     let roundedGross = round(gross)
     let tax = round(gross - net)
+    // The currency every line is priced in — one per cart (the add-to-cart
+    // node refuses a second) — or '' for a cart whose lines name none. The
+    // place-order workflow records and charges the order in it.
+    const cartCurrency = __ccCartCurrency(cart)
+
+    // The subscription in the basket (at most one — the add-to-cart node
+    // refuses a second), whether its first charge is a free trial, and
+    // whether every line is delivered without a parcel (a download or a gift
+    // card). Read off the flags the add-to-cart node and the provider's
+    // hydration stamp, so a storefront exported before them reads as neither.
+    let hasRecurringLines = false
+    let hasRecurringTrial = false
+    let digitalLines = 0
+    for (const item of cart) {
+      if (item && __deBool(item.isRecurring, false)) {
+        hasRecurringLines = true
+        if (Math.floor(Number(item.trialDays)) > 0) hasRecurringTrial = true
+      }
+      if (item && (__deBool(item.isDigital, false) || __deBool(item.isGiftCard, false))) {
+        digitalLines += 1
+      }
+    }
+    const isDigitalOnly = cart.length > 0 && digitalLines === cart.length
 
     // Re-priced HERE, at submit, for the address on the checkout form right
     // now — with the same rule and the same rows the provider displayed from —
     // rather than trusting a figure computed before the buyer's last edit.
     let regional: Record<string, unknown> | null = null
+    let regionalQuote: any = null
     if (regionalSnapshot) {
       const store =
         regionalSnapshot.store && typeof regionalSnapshot.store === 'object'
@@ -163,6 +259,7 @@ async function cart_get_total() {
         selectedRateId,
         currency: regionalSnapshot.currency,
       })
+      regionalQuote = quote
       tax = quote.goodsTax
       roundedGross = quote.goodsGross
       regional = {
@@ -170,13 +267,17 @@ async function cart_get_total() {
         destination: quote.destination,
         zoneName: quote.zone ? quote.zone.name : '',
         rateName: quote.rateName,
+        // The rate the buyer picked, so the server step prices the same one.
+        selectedRateId: quote.selectedRateId || '',
         codAvailable: quote.codAvailable,
         goodsNet: quote.goodsNet,
         goodsTax: quote.goodsTax,
         goodsGross: quote.goodsGross,
-        shippingNet: quote.shippingNet,
-        shippingTax: quote.shippingTax,
-        shippingGross: quote.shippingGross,
+        // A digital-only cart ships nothing, so the zone's fee is not charged
+        // — the provider priced the page the same way.
+        shippingNet: isDigitalOnly ? 0 : quote.shippingNet,
+        shippingTax: isDigitalOnly ? 0 : quote.shippingTax,
+        shippingGross: isDigitalOnly ? 0 : quote.shippingGross,
         taxRate: quote.taxRate,
         taxIncluded: quote.taxIncluded,
         taxDecimals: quote.taxDecimals,
@@ -208,18 +309,185 @@ async function cart_get_total() {
       // rounding, same source of truth.
       total: roundedGross,
       itemCount,
+      currency: cartCurrency,
       // NET sum of the per-product markdowns already reflected in the prices
       // above. Recorded on the order for reporting; never subtracted again.
       productDiscountTotal: round(productDiscount),
       deliveryConfig,
       taxConfig: { storefrontTaxRate },
       voucher,
+      // What the place-order workflow branches on: a subscription opens the
+      // provider's checkout in subscription mode, a digital-only order is
+      // charged no delivery and completes on payment.
+      hasRecurringLines,
+      isDigitalOnly,
     }
     // Absent on a store without regional pricing, which is what tells the
     // place-order workflow to price shipping from `deliveryConfig` as before.
     if (regional) {
       result.regional = regional
     }
+    if (subscriptionsSnapshot) {
+      result.subscriptions = subscriptionsSnapshot
+    }
+    if (paymentKindsSnapshot) {
+      result.paymentKinds = paymentKindsSnapshot
+    }
+
+    // The discount engine and the gift-card tender, re-priced HERE, at submit,
+    // exactly as the provider priced the summary: the same shared rule over the
+    // same lines, rules and shopper context, so the amount the place-order
+    // workflow compares against (`displayedAmountDue`) is the amount the buyer
+    // was shown. Only for a store that mirrored either feature — a legacy
+    // storefront's result keeps every key it ever had and gains none.
+    const discountsEnabled = discountsSnapshot !== null && discountsSnapshot.enabled === true
+    const giftCardsEnabled = giftCardsSnapshot !== null && giftCardsSnapshot.enabled === true
+    if (discountsEnabled || giftCardsEnabled) {
+      // The lines the engine prices: on a regional store already GROSS in the
+      // destination's tax (rate 0), otherwise the stored NET lines with the
+      // storefront rate — the provider's `regionalVoucherItems` projection.
+      let engineItems: any[] = cart
+      let engineTaxRate = storefrontTaxRate
+      // The delivery fee that would be charged before any discount, priced the
+      // way the provider's `computeShippingMeta` / regional quote prices it.
+      let shippingPrice = 0
+      if (regionalQuote) {
+        engineTaxRate = 0
+        shippingPrice = round(Number(regionalQuote.shippingGross) || 0)
+        engineItems = cart.map((item: any, index: number) => {
+          const key =
+            item && item.id !== undefined && item.id !== null ? String(item.id) : String(index)
+          const quoteLines: any[] = Array.isArray(regionalQuote.lines) ? regionalQuote.lines : []
+          for (const line of quoteLines) {
+            if (line && line.key === key) {
+              return { ...item, price: line.unitGross }
+            }
+          }
+          return item
+        })
+      } else if (deliveryConfig && deliveryConfig.deliveryEnabled === true) {
+        const threshold = round(deliveryConfig.freeDeliveryThreshold)
+        // Same half-cent epsilon as the provider, for the same IEEE-754 drift.
+        const shippingIsFree =
+          deliveryConfig.freeDeliveryEnabled && roundedGross + 0.005 >= threshold
+        shippingPrice = shippingIsFree ? 0 : round(deliveryConfig.deliveryPrice)
+      }
+      // Nothing to ship on a digital-only cart: no fee, so nothing to waive —
+      // the provider priced the page the same way.
+      if (isDigitalOnly) {
+        shippingPrice = 0
+      }
+      const customer = customerSnapshot || (discountsSnapshot && discountsSnapshot.customer) || null
+      const rules: unknown[] = []
+      if (
+        discountsEnabled &&
+        discountsSnapshot.automaticDiscounts === true &&
+        Array.isArray(discountsSnapshot.rows)
+      ) {
+        // Exactly the rows the provider priced: the data route served only the
+        // rules the DATABASE calls live, and the browser clock is not asked
+        // again — the same clock re-prices the order server-side, so a rule
+        // that has since ended is caught there and the feed re-read.
+        for (const row of discountsSnapshot.rows) {
+          if (!row || typeof row !== 'object' || row.status !== 'active') continue
+          const rule = __deNormalizeRule(row, 'automatic')
+          if (rule) rules.push(rule)
+        }
+      }
+      const evaluation = __deResolve({
+        rules,
+        voucher: vouchersEnabled && voucher ? __deNormalizeRule(voucher, 'voucher') : null,
+        lines: __deLinesFromCart(engineItems),
+        taxRatePercent: engineTaxRate,
+        shippingPrice,
+        customer: {
+          isFirstOrder:
+            customer && typeof customer.isFirstOrder === 'boolean' ? customer.isFirstOrder : null,
+        },
+        // A store without the rule feed prices its voucher the way its baked
+        // place-order workflow does: no conditions, no stacking.
+        legacy: !discountsEnabled,
+        choice: discountChoice,
+      })
+      const effectiveShipping = Math.max(0, round(shippingPrice - evaluation.shippingDiscount))
+      const deliveryTotal = Math.max(
+        0,
+        round(roundedGross + effectiveShipping - evaluation.goodsDiscount)
+      )
+      if (discountsEnabled) {
+        const appliedIds: string[] = []
+        for (const entry of evaluation.applied) {
+          appliedIds.push(String(entry.id))
+        }
+        result.discounts = {
+          enabled: true,
+          automaticDiscounts: discountsSnapshot.automaticDiscounts === true,
+          rows: Array.isArray(discountsSnapshot.rows) ? discountsSnapshot.rows : null,
+          customer,
+          applied: evaluation.applied,
+          goodsDiscount: evaluation.goodsDiscount,
+          shippingDiscount: evaluation.shippingDiscount,
+          // Order-column shaped: everything each source took, goods and waived
+          // shipping alike, the way `automatic_discount_amount` records it.
+          automaticDiscount: round(
+            evaluation.automaticGoodsDiscount + evaluation.automaticShippingDiscount
+          ),
+          voucherDiscount: round(
+            evaluation.voucherGoodsDiscount + evaluation.voucherShippingDiscount
+          ),
+          appliedIds,
+          // The sets the shopper could choose between and the one applied, so
+          // the place-order workflow prices the order with the same pick.
+          options: evaluation.options,
+          choice: evaluation.choice,
+        }
+      }
+      let displayedAmountDue = deliveryTotal
+      if (giftCardsEnabled) {
+        let giftCard: Record<string, unknown> | null = null
+        // A card pays only in its own currency, so only a cart priced in it:
+        // the cart's currency, or the store's for a cart whose lines name
+        // none — the same gate the provider's tender applies.
+        const tenderCurrency = cartCurrency || __ccCode(giftCardsSnapshot.currency)
+        const cardCurrency = storedGiftCard ? __ccCode(storedGiftCard.currency) : ''
+        if (storedGiftCard && tenderCurrency !== '' && cardCurrency === tenderCurrency) {
+          let hasGiftCardLines = false
+          for (const item of cart) {
+            if (item && __deBool(item.isGiftCard, false)) hasGiftCardLines = true
+          }
+          const balance = Number(storedGiftCard.balance)
+          const tender = __deTender({
+            balance: isFinite(balance) ? balance : 0,
+            // On the DELIVERY total: the larger of the two shapes, so a pickup
+            // order's amount due can only come out lower than what was shown.
+            total: deliveryTotal,
+            currency: tenderCurrency,
+            hasGiftCardLines,
+            // A subscription is billed by the provider every cycle: the card
+            // pays part of the first charge only, none of a free trial, and
+            // nothing at all on a checkout that cannot reduce the first
+            // charge (the provider mirrors whether this one can).
+            hasRecurringLines,
+            recurringTenderAllowed: giftCardsSnapshot.recurringTender === true,
+            hasRecurringTrial,
+          })
+          // A card that pays nothing (no balance, a gift card in the basket) is
+          // not in play — the provider hides it the same way.
+          if (tender.applied > 0) {
+            giftCard = {
+              id: String(storedGiftCard.id),
+              last4: String(storedGiftCard.last4 || ''),
+              balance: isFinite(balance) ? balance : 0,
+              amount: tender.applied,
+              amountDue: tender.amountDue,
+            }
+            displayedAmountDue = tender.amountDue
+          }
+        }
+        result.giftCard = giftCard
+      }
+      result.displayedAmountDue = displayedAmountDue
+    }
     return result
   } catch (_err) {
     return {
@@ -246,6 +514,10 @@ export const cartGetTotal: NodeHandlerGenerator = {
     return (
       source.slice(0, bodyStart) +
       RegionalPricing.generateRegionalPricingHelperCode() +
+      '\n' +
+      DiscountEngine.generateDiscountEngineHelperCode() +
+      '\n' +
+      CartCurrency.generateCartCurrencyHelperCode() +
       source.slice(bodyStart)
     )
   },