@tallyui/pos 0.1.0 → 3.0.0-next.0

package/src/order/order-builder.ts

@@ -1,7 +1,9 @@
 import { BehaviorSubject, type Observable } from 'rxjs';
-import type { ProductTraits } from '@tallyui/core';
+import { resolvePrice, type ProductTraits, type TaxRounding } from '@tallyui/core';
 import type { TaxContext } from '../tax/types';
-import { calculateTax } from '../tax/calculate';
+import { taxMicros, roundMicrosToMinor, roundedTaxByRate } from '../tax/exact';
+import { taxLogger } from '../tax/tax-provider';
+import { allocateOrderDiscount } from './allocate-order-discount';
 import type {
   Order,
   LineItem,
@@ -9,13 +11,55 @@ import type {
   AppliedDiscount,
   Payment,
   CustomerSummary,
+  AddLineInput,
 } from './types';
 
+/** Tax contexts already warned that per_rate_group_items fell back to per_order for inclusive lines (#287). */
+const perRateGroupWarned = new WeakSet<TaxContext>();
+
 let nextId = 0;
 function uid(): string {
   return `${Date.now()}-${++nextId}`;
 }
 
+function roundHalfAway(n: number): number {
+  return Math.sign(n) * Math.round(Math.abs(n));
+}
+
+/** The settlement totals of recalculated lines; the display figures derive from them (ADR-063). */
+function sumLines(lines: LineItem[], rounding?: TaxRounding): { subtotalMinor: number; taxMinor: number; totalMinor: number } {
+  // per_line_items, per_rate_group_items (#287): total = Σ rounded nets + tax (order-level-tax-calculation-strategy.js:44-49, order.entity.js:88-89).
+  const rounded = roundedTaxByRate(lines, rounding);
+  if (rounded) return { subtotalMinor: rounded.baseMinor, taxMinor: rounded.taxMinor, totalMinor: Math.max(0, rounded.baseMinor + rounded.taxMinor) };
+  const mode = rounding?.granularity === 'per_order' ? rounding.mode : undefined;
+  const netMinor = lines.reduce((sum, li) => sum + li.netMinor, 0);
+  const lineTaxMicros = lines.reduce((sum, li) => sum + BigInt(li.taxMicros), 0n);
+  const exclusiveTaxMicros = lines.reduce((sum, li) => li.taxInclusive ? sum : sum + BigInt(li.taxMicros), 0n);
+  const taxMinor = roundMicrosToMinor(lineTaxMicros, mode);
+  // Each line pays in its own mode: an inclusive line its gross, an exclusive line its net plus tax.
+  // The totals sum the lines as recalculated; nothing is subtracted after tax.
+  const linesTotal = netMinor + roundMicrosToMinor(exclusiveTaxMicros, mode);
+  return { subtotalMinor: linesTotal - taxMinor, taxMinor, totalMinor: Math.max(0, linesTotal) };
+}
+
+/** An own-mode amount on a line, in the display mode, converted on its own at the line's rates (ADR-063). */
+function toDisplayMode(line: LineItem, amountMinor: number, displayInclusive: boolean): number {
+  if (line.taxInclusive === displayInclusive) return amountMinor;
+  const ratePpm = line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0);
+  const taxMinor = roundMicrosToMinor(taxMicros(amountMinor, ratePpm, line.taxInclusive));
+  return line.taxInclusive ? amountMinor - taxMinor : amountMinor + taxMinor;
+}
+
+/**
+ * The display residue's guard (ADR-063); throws when the arithmetic is wrong rather than rounded. With no converted
+ * line it's exactly 0 (Σ gross = Σ net + Σ discounts). Otherwise each of the n non-zero rounded conversions is off by
+ * at most half a cent, and the order-level tax rounding by at most one more, so |residue| ≤ ⌊n/2⌋ + 1.
+ */
+export function assertDisplayResidue(residue: number, convertedLines: number, conversions: number): void {
+  const bound = convertedLines === 0 ? 0 : Math.floor(conversions / 2) + 1;
+  if (Math.abs(residue) > bound) throw new Error(`Display residue ${residue} exceeds its bound of ${bound} (ADR-063)`);
+}
+
 export interface OrderBuilderOptions {
   currency: string;
   taxContext: TaxContext;
@@ -25,6 +69,7 @@ export interface OrderBuilderOptions {
 export interface OrderBuilder {
   order$: Observable<Order>;
   addProduct(doc: any, traits: ProductTraits, options?: { variantId?: string; quantity?: number }): string;
+  addLine(input: AddLineInput): string;
   updateQuantity(lineId: string, quantity: number): void;
   removeItem(lineId: string): void;
   applyLineDiscount(lineId: string, discount: Discount): void;
@@ -39,7 +84,8 @@ export interface OrderBuilder {
 }
 
 export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
-  const { currency, taxContext } = options;
+  const { taxContext } = options;
+  const currency = options.currency.toUpperCase();
   const orderId = options.id ?? uid();
 
   let lineItems: LineItem[] = [];
@@ -51,81 +97,161 @@ export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
 
   const subject = new BehaviorSubject<Order>(buildOrder());
 
-  function recalculateLine(line: LineItem): LineItem {
-    const gross = line.price * line.quantity;
-
-    // Recompute discount amounts from current gross
-    const recalcedDiscounts = line.discounts.map((d) => ({
-      ...d,
-      amount: computeDiscountAmount(d, gross),
-    }));
-
-    const discountAmount = recalcedDiscounts.reduce((sum, d) => sum + d.amount, 0);
-    const afterDiscount = gross - discountAmount;
-    const tax = calculateTax(afterDiscount, line.taxRate, taxContext.pricesIncludeTax);
+  /** Stored lines carry no order share; buildOrder recalculates each with its allocated share (ADR-062). */
+  function recalculateLine(line: LineItem, orderDiscountMinor = 0): LineItem {
+    const grossMinor = line.unitPriceMinor * line.quantity;
+
+    // Each amount is what that discount actually removed, capped at what's left, matching buildOrder's order-discount path (ADR-062).
+    let remaining = grossMinor;
+    const recalcedDiscounts = line.discounts.map((d) => {
+      const amountMinor = Math.min(remaining, computeDiscountAmount(d, d.type === 'percentage' ? grossMinor : remaining));
+      remaining -= amountMinor;
+      return { ...d, amountMinor };
+    });
+
+    // The order share never exceeds what the line discounts leave (allocateOrderDiscount's bound).
+    const lineDiscountMinor = Math.min(grossMinor, recalcedDiscounts.reduce((sum, d) => sum + d.amountMinor, 0));
+    const discountMinor = lineDiscountMinor + orderDiscountMinor;
+    const netMinor = grossMinor - discountMinor;
+    const combinedRate = line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0);
+    // Tax in the line's own mode, from its own unit price × quantity: never re-tax a rounded base.
+    const inclusiveTax = line.taxInclusive ? taxMicros(netMinor, combinedRate, true) : 0n;
+    let allocatedTax = 0n;
+    const taxLines = line.taxLines.map((tax, index) => {
+      const micros = line.taxInclusive
+        ? index === line.taxLines.length - 1
+          ? inclusiveTax - allocatedTax
+          : combinedRate === 0 ? 0n : inclusiveTax * BigInt(tax.ratePpm) / BigInt(combinedRate)
+        : taxMicros(netMinor, tax.ratePpm, false);
+      allocatedTax += micros;
+      return { ...tax, taxMicros: micros.toString() };
+    });
 
     return {
       ...line,
       discounts: recalcedDiscounts,
-      discountAmount,
-      taxAmount: tax.taxAmount,
-      lineTotal: taxContext.pricesIncludeTax ? afterDiscount : afterDiscount + tax.taxAmount,
+      discountMinor,
+      orderDiscountMinor,
+      netMinor,
+      taxLines,
+      taxMicros: allocatedTax.toString(),
     };
   }
 
   function computeDiscountAmount(discount: Discount, base: number): number {
+    // Clamped here so both line and order discounts can never go negative (a negative
+    // percentage or fixed value would otherwise raise the price instead of lowering it).
     if (discount.type === 'percentage') {
-      return Math.round((base * discount.value) / 100 * 100) / 100;
+      return Math.max(0, roundHalfAway(base * discount.value / 100));
     }
-    return Math.min(discount.value, base);
+    if (!Number.isInteger(discount.value)) throw new RangeError('Fixed discount must be integer minor units');
+    return Math.max(0, Math.min(discount.value, base));
   }
 
   function buildOrder(): Order {
-    const subtotalLines = lineItems.reduce((sum, li) => {
-      const lineGross = li.price * li.quantity - li.discountAmount;
-      if (taxContext.pricesIncludeTax) {
-        const tax = calculateTax(lineGross, li.taxRate, true);
-        return sum + tax.priceExclTax;
+    // Order discounts are pre-tax (ADR-062). The base is the lines' pre-order-discount amounts, each in its
+    // own mode (an inclusive line's shelf amount, an exclusive line's net). A percentage discount is additive:
+    // each is computed on that base, not on what an earlier order discount leaves (WCPOS `next` / WooCommerce
+    // parity). A fixed discount is computed on what remains, as before. Every discount is then capped at what
+    // remains, which decreases as each is applied, and the total is allocated to the lines, which are then
+    // taxed on what is left.
+    const lineAmounts = lineItems.map((li) => li.netMinor);
+    const base = lineAmounts.reduce((sum, amount) => sum + Math.max(0, amount), 0);
+    let remaining = base;
+    const recalcedOrderDiscounts = orderDiscounts.map((d) => {
+      const amountMinor = Math.min(remaining, computeDiscountAmount(d, d.type === 'percentage' ? base : remaining));
+      remaining -= amountMinor;
+      return { ...d, amountMinor };
+    });
+    const shares = allocateOrderDiscount(lineAmounts, recalcedOrderDiscounts.reduce((sum, d) => sum + d.amountMinor, 0));
+    const lines = lineItems.map((li, index) => recalculateLine(li, shares[index]));
+
+    const { subtotalMinor, taxMinor, totalMinor } = sumLines(lines, taxContext.rounding);
+    if (taxContext.rounding?.granularity === 'per_rate_group_items' && lines.some((li) => li.taxInclusive) && !perRateGroupWarned.has(taxContext)) {
+      perRateGroupWarned.add(taxContext);
+      taxLogger.warn('per_rate_group_items with inclusive lines: using per_order figures until the display has a rounding row (#287, #310)');
+    }
+    const discountMinor = lines.reduce((sum, li) => sum + li.discountMinor, 0);
+    // Display figures (ADR-063): every discount the cashier entered, and each line's order share, converted on its own
+    // into the display mode. A line in the display mode shows quantity × unit price; a converted line shows its
+    // converted remaining (netMinor) plus its rows and share, so it's never less than them. The subtotal is derived
+    // from the settlement total, so every sum is exact; the rounding residue goes to the converted lines' amounts,
+    // never to a discount or an unconverted line.
+    const taxInclusive = taxContext.pricesIncludeTax;
+    const figures = lines.map((li) => {
+      // A negative-priced (return) line shows what settlement charges for it (recalculateLine caps it at 0 today),
+      // with no rows: its capped "discounts" are the negative gross cancelled, not money off.
+      const returned = li.unitPriceMinor < 0;
+      const discounts = returned ? [] : li.discounts.map((d) => ({
+        discountId: d.id, ...(d.label !== undefined ? { label: d.label } : {}), amountMinor: toDisplayMode(li, d.amountMinor, taxInclusive),
+      }));
+      const shareMinor = toDisplayMode(li, li.orderDiscountMinor, taxInclusive);
+      const remainingMinor = toDisplayMode(li, li.netMinor, taxInclusive);
+      const amountMinor = li.taxInclusive === taxInclusive && !returned ? li.unitPriceMinor * li.quantity
+        : discounts.reduce((sum, d) => sum + d.amountMinor, remainingMinor + shareMinor);
+      return { line: { lineId: li.id, amountMinor, discounts }, shareMinor, remainingMinor, returned };
+    });
+    const displayLines = figures.map((f) => f.line);
+    const orderDiscountDisplay = figures.reduce((sum, f) => sum + f.shareMinor, 0);
+    const displayDiscount = displayLines.reduce(
+      (sum, line) => line.discounts.reduce((lineSum, d) => lineSum + d.amountMinor, sum), orderDiscountDisplay);
+    const displaySubtotal = (taxInclusive ? totalMinor : totalMinor - taxMinor) + displayDiscount;
+    const residue = displaySubtotal - displayLines.reduce((sum, line) => sum + line.amountMinor, 0);
+    const converted = lines.flatMap((li, index) => li.taxInclusive === taxInclusive ? [] : [index]);
+    const conversions = converted.reduce((count, index) => count + [lines[index].netMinor, lines[index].orderDiscountMinor,
+      ...lines[index].discounts.map((d) => d.amountMinor)].filter((x) => x !== 0).length, 0);
+    assertDisplayResidue(residue, converted.length, conversions);
+    // Largest converted remaining first (ties to the earlier line). A negative residue takes a line down to its rows
+    // and share at most, then moves on: six 2-cent inclusive lines can owe −3 with no line above 2. The spill is a
+    // crash guard; it never fired in a 200k-cart fuzz. Negative-priced (return) lines convert as they are and never
+    // take residue; refunds get their own design.
+    let left = residue;
+    const takers = converted.filter((index) => !figures[index].returned);
+    for (const index of takers.sort((a, b) => figures[b].remainingMinor - figures[a].remainingMinor || a - b)) {
+      if (left === 0) break;
+      const take = left > 0 ? left : Math.max(left, -figures[index].remainingMinor);
+      displayLines[index].amountMinor += take;
+      left -= take;
+    }
+    if (left !== 0) throw new Error(`Display residue ${left} left over with no converted line to take it (ADR-063)`);
+    // Checked here, not only in tests: every figure >= 0, and no line shows less than its own rows and share (lines
+    // with a non-negative gross; a return line's negative amount is its own).
+    if (displayDiscount < 0) throw new Error(`Display discount ${displayDiscount} is negative (ADR-063)`);
+    for (const { line, shareMinor, returned } of figures) {
+      if (returned && line.discounts.length > 0) throw new Error(`Return line ${line.lineId} shows discount rows (ADR-063)`);
+      if (returned) continue;
+      const rows = line.discounts.reduce((sum, d) => sum + d.amountMinor, 0);
+      if (shareMinor < 0 || line.discounts.some((d) => d.amountMinor < 0) || line.amountMinor < rows + shareMinor) {
+        throw new Error(`Display line ${line.lineId} shows ${line.amountMinor}, less than its rows ${rows} and share ${shareMinor} (ADR-063)`);
       }
-      return sum + lineGross;
-    }, 0);
-
-    const subtotal = Math.round(subtotalLines * 100) / 100;
-
-    const recalcedOrderDiscounts = orderDiscounts.map((d) => ({
-      ...d,
-      amount: computeDiscountAmount(d, subtotal),
-    }));
-
-    const discountTotal =
-      lineItems.reduce((sum, li) => sum + li.discountAmount, 0) +
-      recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
-
-    const taxTotal = lineItems.reduce((sum, li) => sum + li.taxAmount, 0);
-
-    const total = lineItems.reduce((sum, li) => sum + li.lineTotal, 0) -
-      recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
-
-    const roundedTotal = Math.round(total * 100) / 100;
-    const paidAmount = payments.reduce((sum, p) => sum + p.amount, 0);
-    const balanceDue = Math.max(0, Math.round((roundedTotal - paidAmount) * 100) / 100);
-    const changeDue = Math.max(0, Math.round((paidAmount - roundedTotal) * 100) / 100);
+    }
+    const display = {
+      taxInclusive, subtotalMinor: displaySubtotal, discountMinor: displayDiscount, taxMinor, totalMinor,
+      lines: displayLines, orderDiscountMinor: orderDiscountDisplay,
+    };
+    const paidMinor = payments.reduce((sum, p) => sum + p.amountMinor, 0);
+    const balanceDueMinor = Math.max(0, totalMinor - paidMinor);
+    const changeDueMinor = Math.max(0, paidMinor - totalMinor);
 
     return {
       id: orderId,
       status: 'draft',
-      lineItems: [...lineItems],
+      lineItems: lines,
       discounts: recalcedOrderDiscounts,
       payments: [...payments],
       customer,
       note,
-      subtotal,
-      discountTotal: Math.round(discountTotal * 100) / 100,
-      taxTotal: Math.round(taxTotal * 100) / 100,
-      total: roundedTotal,
-      balanceDue,
-      changeDue,
+      subtotalMinor,
+      discountMinor,
+      taxMinor,
+      totalMinor,
+      display,
+      paidMinor,
+      balanceDueMinor,
+      changeDueMinor,
       currency,
+      pricesIncludeTax: taxContext.pricesIncludeTax,
+      ...(taxContext.rounding ? { taxRounding: taxContext.rounding } : {}),
       createdAt: now,
       updatedAt: new Date().toISOString(),
     };
@@ -135,51 +261,86 @@ export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
     subject.next(buildOrder());
   }
 
+  function addLine(input: AddLineInput): string {
+    const { productId, variantId, unitPrice } = input;
+    const quantity = input.quantity ?? 1;
+    if (unitPrice.currency !== currency) throw new RangeError('Line currency must match ' + currency);
+    if (!Number.isInteger(unitPrice.amount)) throw new RangeError('Price must be integer minor units');
+    if (!Number.isInteger(quantity) || quantity < 1) throw new RangeError('Quantity must be an integer >= 1');
+    // A rate from the tax class carries the backend's name for it when one is mapped (#287, #288).
+    const code = input.taxRates ? undefined : taxContext.getTaxRateCode?.(input.taxClass);
+    const taxRates = input.taxRates ?? [{ ...(code !== undefined ? { code } : {}), ratePpm: taxContext.getTaxRatePpm(input.taxClass) }];
+    const taxInclusive = unitPrice.taxInclusive ?? taxContext.pricesIncludeTax;
+
+    const existing = lineItems.find(
+      (li) => li.productId === productId && li.variantId === variantId && li.taxInclusive === taxInclusive
+        && li.unitPriceMinor === unitPrice.amount && li.taxLines.length === taxRates.length
+        && li.taxLines.every((tax, index) => tax.code === taxRates[index].code && tax.ratePpm === taxRates[index].ratePpm),
+    );
+
+    if (existing) {
+      lineItems = lineItems.map((li) =>
+        li.id === existing.id ? recalculateLine({ ...li, quantity: li.quantity + quantity }) : li,
+      );
+      emit();
+      return existing.id;
+    }
+
+    const lineId = uid();
+    const line: LineItem = {
+      id: lineId,
+      productId,
+      variantId,
+      name: input.name,
+      sku: input.sku ?? '',
+      imageUrl: input.imageUrl,
+      unitPriceMinor: unitPrice.amount,
+      quantity,
+      taxLines: taxRates.map((tax) => ({ ...tax, taxMicros: '0' })),
+      discounts: [],
+      discountMinor: 0,
+      orderDiscountMinor: 0,
+      netMinor: 0,
+      taxMicros: '0',
+      taxInclusive,
+      // TV4b derives the store-level flag with Medusa's own precedence (region
+      // preference, then currency), so a disagreement should be rare. It can
+      // still happen, for example when a price preference changes after the
+      // settings were read. Keeping the line in its own mode means the customer
+      // pays exactly the shelf price, as Medusa's checkout would.
+      ...(taxInclusive !== taxContext.pricesIncludeTax
+        ? { priceTaxModeConverted: taxInclusive ? 'inclusive-to-exclusive' as const : 'exclusive-to-inclusive' as const }
+        : {}),
+    };
+
+    lineItems = [...lineItems, recalculateLine(line)];
+    emit();
+    return lineId;
+  }
+
   return {
     order$: subject.asObservable(),
+    addLine,
 
     addProduct(doc, traits, opts) {
       const productId = traits.getId(doc);
-      const variantId = opts?.variantId;
-      const quantity = opts?.quantity ?? 1;
-
-      const existing = lineItems.find(
-        (li) => li.productId === productId && li.variantId === variantId,
-      );
-
-      if (existing) {
-        existing.quantity += quantity;
-        lineItems = lineItems.map((li) =>
-          li.id === existing.id ? recalculateLine(existing) : li,
-        );
-        emit();
-        return existing.id;
-      }
-
-      const priceStr = traits.getPrice(doc);
-      const price = priceStr ? parseFloat(priceStr) : 0;
-      const taxRate = taxContext.getTaxRate();
-
-      const lineId = uid();
-      const line: LineItem = {
-        id: lineId,
+      if (!traits.isSellable(doc)) throw new Error("addProduct: this product isn't sold in this store's channel");
+      const variant = opts?.variantId !== undefined && traits.getVariants
+        ? traits.getVariants(doc, { currency }).find((variant) => variant.id === opts.variantId) : undefined;
+      if (opts?.variantId !== undefined && traits.getVariants && !variant)
+        throw new Error(`Unknown variant ${opts.variantId} for product ${productId}`);
+      const unitPrice = resolvePrice(variant ? variant.prices : traits.getPrices(doc, { currency }), currency)?.current;
+      if (!unitPrice) throw new Error('No price in ' + currency + ' for product ' + productId);
+      return addLine({
         productId,
-        variantId,
+        variantId: opts?.variantId,
         name: traits.getName(doc),
-        sku: traits.getSku(doc) ?? '',
+        sku: variant?.sku ?? traits.getSku(doc),
         imageUrl: traits.getImageUrl(doc),
-        price,
-        quantity,
-        taxRate,
-        taxAmount: 0,
-        discounts: [],
-        discountAmount: 0,
-        lineTotal: 0,
-      };
-
-      lineItems = [...lineItems, recalculateLine(line)];
-      emit();
-      return lineId;
+        unitPrice,
+        quantity: opts?.quantity,
+        taxClass: traits.getTaxClass?.(doc, opts?.variantId),
+      });
     },
 
     updateQuantity(lineId, quantity) {
@@ -202,11 +363,11 @@ export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
     applyLineDiscount(lineId, discount) {
       lineItems = lineItems.map((li) => {
         if (li.id !== lineId) return li;
-        const base = li.price * li.quantity;
+        const base = li.unitPriceMinor * li.quantity;
         const applied: AppliedDiscount = {
           ...discount,
           id: uid(),
-          amount: computeDiscountAmount(discount, base),
+          amountMinor: computeDiscountAmount(discount, base),
         };
         return recalculateLine({ ...li, discounts: [...li.discounts, applied] });
       });
@@ -217,7 +378,7 @@ export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
       const applied: AppliedDiscount = {
         ...discount,
         id: uid(),
-        amount: 0,
+        amountMinor: computeDiscountAmount(discount, 0),
       };
       orderDiscounts = [...orderDiscounts, applied];
       emit();

package/src/order/order-manager.ts

@@ -1,6 +1,7 @@
 import { BehaviorSubject, map, type Observable } from 'rxjs';
 import type { RxCollection } from 'rxdb';
 import type { TaxContext } from '../tax/types';
+import { customerRefusal } from '../pos-order/command';
 import { createOrderBuilder, type OrderBuilder } from './order-builder';
 import type { Order } from './types';
 
@@ -8,7 +9,7 @@ export interface ParkedOrderSummary {
   id: string;
   customerName?: string;
   itemCount: number;
-  total: number;
+  totalMinor: number;
   parkedAt: string;
   source: 'local' | 'server';
 }
@@ -29,7 +30,8 @@ export interface OrderManager {
 }
 
 export function createOrderManager(options: OrderManagerOptions): OrderManager {
-  const { currency, taxContext, draftsCollection } = options;
+  const { taxContext, draftsCollection } = options;
+  const currency = options.currency.toUpperCase();
 
   let activeBuilder = createOrderBuilder({ currency, taxContext });
   const activeSubject = new BehaviorSubject<OrderBuilder>(activeBuilder);
@@ -42,7 +44,7 @@ export function createOrderManager(options: OrderManagerOptions): OrderManager {
           id: json.id,
           customerName: json.customerName || undefined,
           itemCount: json.itemCount ?? 0,
-          total: json.total ?? 0,
+          totalMinor: json.total ?? 0,
           parkedAt: json.parkedAt ?? '',
           source: 'local' as const,
         };
@@ -67,7 +69,7 @@ export function createOrderManager(options: OrderManagerOptions): OrderManager {
         data: JSON.stringify(snapshot),
         customerName: snapshot.customer?.name ?? '',
         itemCount: snapshot.lineItems.length,
-        total: snapshot.total,
+        total: snapshot.totalMinor,
         parkedAt: new Date().toISOString(),
       });
 
@@ -90,54 +92,33 @@ export function createOrderManager(options: OrderManagerOptions): OrderManager {
       });
 
       // Restore state from saved order
-      if (savedOrder.customer) {
+      // A customer whose email or id order.create would refuse (see useSale's setCustomer) isn't restored.
+      if (savedOrder.customer && !customerRefusal(savedOrder.customer)) {
         builder.setCustomer(savedOrder.customer);
       }
       if (savedOrder.note) {
         builder.setNote(savedOrder.note);
       }
 
-      // Restore line items using synthetic traits
+      // Restore line items and their discounts
       for (const line of savedOrder.lineItems) {
-        const syntheticTraits = {
-          getId: (d: any) => d.productId,
-          getName: (d: any) => d.name,
-          getSku: (d: any) => d.sku,
-          getPrice: (d: any) => String(d.price),
-          getRegularPrice: (d: any) => String(d.price),
-          getSalePrice: () => undefined,
-          isOnSale: () => false,
-          getImageUrl: (d: any) => d.imageUrl,
-          getImageUrls: (d: any) => (d.imageUrl ? [d.imageUrl] : []),
-          getDescription: () => undefined,
-          getStockStatus: () => 'instock' as const,
-          getStockQuantity: () => null,
-          hasVariants: () => false,
-          getType: () => 'simple',
-          getBarcode: () => undefined,
-          getCategoryNames: () => [],
-        };
-        builder.addProduct(line, syntheticTraits, {
+        const lineId = builder.addLine({
+          productId: line.productId,
           variantId: line.variantId,
+          name: line.name,
+          sku: line.sku,
+          imageUrl: line.imageUrl,
+          unitPrice: { amount: line.unitPriceMinor, currency, taxInclusive: line.taxInclusive },
           quantity: line.quantity,
+          taxRates: line.taxLines.map(({ code, ratePpm }) => ({ code, ratePpm })),
         });
-      }
-
-      // Restore line-level discounts
-      const resumedOrder = builder.getSnapshot();
-      for (const savedLine of savedOrder.lineItems) {
-        const newLine = resumedOrder.lineItems.find(
-          (li) => li.productId === savedLine.productId && li.variantId === savedLine.variantId,
-        );
-        if (newLine) {
-          for (const discount of savedLine.discounts) {
-            builder.applyLineDiscount(newLine.id, {
-              type: discount.type,
-              value: discount.value,
-              label: discount.label,
-              couponCode: discount.couponCode,
-            });
-          }
+        for (const discount of line.discounts) {
+          builder.applyLineDiscount(lineId, {
+            type: discount.type,
+            value: discount.value,
+            label: discount.label,
+            couponCode: discount.couponCode,
+          });
         }
       }
 
@@ -155,7 +136,9 @@ export function createOrderManager(options: OrderManagerOptions): OrderManager {
       for (const payment of savedOrder.payments) {
         builder.addPayment({
           method: payment.method,
-          amount: payment.amount,
+          amountMinor: payment.amountMinor,
+          tenderedMinor: payment.tenderedMinor,
+          changeMinor: payment.changeMinor,
           reference: payment.reference,
         });
       }

package/src/order/tax-figures.ts

@@ -0,0 +1,23 @@
+import type { TaxRounding } from '@tallyui/core';
+import { createOrderBuilder } from './order-builder';
+import { taxLinesByRate } from '../tax/exact';
+
+/** A sent line; `discountMinor` is its `lines[].discountMinor` (line discounts + its order share), in its own mode. */
+export type BasketLine = { unitPriceMinor: number; quantity: number; discountMinor?: number; taxInclusive: boolean; taxLines: Array<{ code?: string; ratePpm: number }> };
+
+/**
+ * The till's settlement figures for a sent basket under a store's strategy (#287), computed exactly as a sale computes
+ * them, so a backend can score its own orders against the till (vendurepos/app#38). Each discountMinor is applied as a
+ * fixed line discount in the line's own mode.
+ */
+export function taxFiguresForBasket(currency: string, pricesIncludeTax: boolean, lines: readonly BasketLine[], rounding?: TaxRounding) {
+  const code = currency.toUpperCase();
+  const builder = createOrderBuilder({ currency: code, taxContext: { getTaxRatePpm: () => 0, pricesIncludeTax, ...(rounding ? { rounding } : {}) } });
+  lines.forEach((line, index) => {
+    const lineId = builder.addLine({ productId: `line-${index}`, name: `Line ${index}`, quantity: line.quantity,
+      unitPrice: { amount: line.unitPriceMinor, currency: code, taxInclusive: line.taxInclusive }, taxRates: line.taxLines });
+    if (line.discountMinor) builder.applyLineDiscount(lineId, { type: 'fixed', value: line.discountMinor });
+  });
+  const { subtotalMinor, taxMinor, totalMinor, lineItems, taxRounding } = builder.getSnapshot();
+  return { subtotalMinor, taxMinor, totalMinor, taxByRate: taxLinesByRate(lineItems, taxMinor, undefined, taxRounding) };
+}