@tallyui/pos 2.0.0 → 3.0.0-next.1

package/dist/index.js

@@ -111,6 +111,7 @@ function useCurrencyCode() {
 
 // src/tax/exact.ts
 var MICROS_PER_MINOR = 1000000n;
+var DEFAULT_TAX_ROUNDING = { granularity: "per_order", mode: "half_away_from_zero" };
 function ratePpmFromPercent(percent) {
   const value = String(percent);
   const match = /^(\d+)(?:\.(\d{1,4}))?$/.exec(value);
@@ -134,9 +135,13 @@ function taxMicros(amountMinor, ratePpm, pricesIncludeTax) {
   const sign = numerator < 0n ? -1n : 1n;
   return sign * ((sign * numerator + denominator / 2n) / denominator);
 }
-function roundMicrosToMinor(micros) {
-  const sign = micros < 0n ? -1n : 1n;
-  const minor2 = sign * ((sign * micros + MICROS_PER_MINOR / 2n) / MICROS_PER_MINOR);
+function roundRatio(n, d, mode = "half_away_from_zero") {
+  if (mode === "half_away_from_zero" && n < 0n) return -roundRatio(-n, d, mode);
+  const a = 2n * n + d, b = 2n * d;
+  return a / b - (a < 0n && a % b !== 0n ? 1n : 0n);
+}
+function roundMicrosToMinor(micros, mode) {
+  const minor2 = roundRatio(micros, MICROS_PER_MINOR, mode);
   if (minor2 < -BigInt(Number.MAX_SAFE_INTEGER) || minor2 > BigInt(Number.MAX_SAFE_INTEGER)) {
     throw new RangeError("Rounded amount must be a safe integer");
   }
@@ -177,7 +182,38 @@ function computeOrderTax(lines, pricesIncludeTax) {
     lineTaxMicros
   };
 }
-function taxLinesByRate(lines, orderTaxMinor, taxLabels) {
+function roundedTaxByRate(lines, rounding) {
+  if (rounding?.granularity !== "per_line_items" && rounding?.granularity !== "per_rate_group_items") return void 0;
+  if (rounding.granularity === "per_rate_group_items" && lines.some((line) => line.taxInclusive)) return void 0;
+  const { granularity, mode } = rounding;
+  const rates = /* @__PURE__ */ new Map();
+  let baseMinor = 0n;
+  const items = lines.flatMap((line) => (line.discountMinor ?? 0) > 0 ? [{ ...line, netMinor: line.netMinor + line.discountMinor }, { ...line, netMinor: -line.discountMinor }] : [line]);
+  for (const line of items) {
+    const net = BigInt(line.netMinor);
+    const ratePpm = BigInt(line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0));
+    const base = line.taxInclusive ? roundRatio(net * MICROS_PER_MINOR, MICROS_PER_MINOR + ratePpm, mode) : net;
+    const lineTax = line.taxInclusive ? net - base : roundRatio(net * ratePpm, MICROS_PER_MINOR, mode);
+    let left = lineTax;
+    baseMinor += base;
+    line.taxLines.forEach((tax, index) => {
+      const key = JSON.stringify([tax.code ?? "", tax.ratePpm]);
+      const row = rates.get(key) ?? { code: tax.code, ratePpm: tax.ratePpm, netMinor: 0n, amountMinor: 0n };
+      const share = index === line.taxLines.length - 1 ? left : ratePpm === 0n ? 0n : roundRatio(lineTax * BigInt(tax.ratePpm), ratePpm, mode);
+      left -= share;
+      rates.set(key, { ...row, netMinor: row.netMinor + base, amountMinor: row.amountMinor + share });
+    });
+  }
+  const rows = [...rates.values()].map((row) => ({ ...row, netMinor: Number(row.netMinor), amountMinor: Number(
+    // per_rate_group_items: round(Σ net × r) once per group, and the order's tax is their sum (:35-49, :56).
+    granularity === "per_rate_group_items" ? roundRatio(row.netMinor * BigInt(row.ratePpm), MICROS_PER_MINOR, mode) : row.amountMinor
+  ) }));
+  return { baseMinor: Number(baseMinor), taxMinor: rows.reduce((sum, row) => sum + row.amountMinor, 0), rates: rows };
+}
+function taxLinesByRate(lines, orderTaxMinor, taxLabels, rounding) {
+  const label = (ratePpm) => taxLabels?.[ratePpm] ?? `Tax ${ratePpm / 1e4}%`;
+  const rounded = roundedTaxByRate(lines, rounding);
+  if (rounded) return rounded.rates.map(({ code, ratePpm, netMinor, amountMinor }) => ({ label: label(ratePpm), code, ratePpm, netMinor, amountMinor }));
   const byRate = /* @__PURE__ */ new Map();
   for (const line of lines) {
     const lineTaxMicros = line.taxLines.reduce((sum, tax) => sum + BigInt(tax.taxMicros), 0n);
@@ -196,7 +232,7 @@ function taxLinesByRate(lines, orderTaxMinor, taxLabels) {
   const groups = Array.from(byRate.values()).map(({ code, ratePpm, micros, netMinor }) => {
     const floor = micros / MICROS_PER_MINOR - (micros < 0n && micros % MICROS_PER_MINOR !== 0n ? 1n : 0n);
     return {
-      line: { label: taxLabels?.[ratePpm] ?? `Tax ${ratePpm / 1e4}%`, code, ratePpm, netMinor, amountMinor: Number(floor) },
+      line: { label: label(ratePpm), code, ratePpm, netMinor, amountMinor: Number(floor) },
       remainder: micros - floor * MICROS_PER_MINOR
     };
   });
@@ -209,19 +245,34 @@ function taxLinesByRate(lines, orderTaxMinor, taxLabels) {
 // src/tax/tax-provider.tsx
 import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2 } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
+var taxLogger = createLogger("tax");
 var TaxCtx = createContext2(null);
-function TaxProvider({ ratesPpm, pricesIncludeTax, children }) {
+function TaxProvider({ ratesPpm, pricesIncludeTax, rounding, rateCodes, children }) {
   const value = useMemo2(
     () => {
       if (Object.values(ratesPpm).some((rate) => !Number.isSafeInteger(rate) || rate < 0)) {
         throw new RangeError("TaxProvider: rates must be integer ppm");
       }
+      const unknown = /* @__PURE__ */ new Set();
       return {
-        getTaxRatePpm: (taxClass) => (taxClass === void 0 ? void 0 : ratesPpm[taxClass]) ?? ratesPpm.default ?? 0,
-        pricesIncludeTax
+        getTaxRatePpm: (taxClass) => {
+          if (taxClass !== void 0 && Object.hasOwn(ratesPpm, taxClass)) return ratesPpm[taxClass];
+          if (taxClass !== void 0 && !unknown.has(taxClass)) {
+            unknown.add(taxClass);
+            taxLogger.warn("No tax rate for this tax class; using the default rate", { taxClass });
+          }
+          return ratesPpm.default ?? 0;
+        },
+        // The name of the rate getTaxRatePpm picks: the class's own, else the default's.
+        getTaxRateCode: (taxClass) => {
+          const key = taxClass !== void 0 && Object.hasOwn(ratesPpm, taxClass) ? taxClass : "default";
+          return rateCodes && Object.hasOwn(rateCodes, key) ? rateCodes[key] : void 0;
+        },
+        pricesIncludeTax,
+        ...rounding ? { rounding } : {}
       };
     },
-    [ratesPpm, pricesIncludeTax]
+    [ratesPpm, pricesIncludeTax, rounding, rateCodes]
   );
   return /* @__PURE__ */ jsx2(TaxCtx.Provider, { value, children });
 }
@@ -267,40 +318,79 @@ function withPricingContext(context, settings) {
   return settings.pricingContext ? { ...rest, pricingContext: settings.pricingContext } : rest;
 }
 function taxProviderProps(settings) {
-  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax };
+  const rounding = settings.taxRounding?.granularity === "custom" ? void 0 : settings.taxRounding;
+  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax, ...rounding && { rounding }, ...settings.taxRateCodes && { rateCodes: settings.taxRateCodes } };
 }
 
 // src/store-settings/use-store-settings.ts
 import { useCallback as useCallback2, useEffect, useRef, useState } from "react";
 var LOADING = { state: "loading" };
+var StoreCapabilitiesUnavailableError = class extends Error {
+  constructor(cause) {
+    super("Store capabilities unavailable", { cause });
+    this.name = "StoreCapabilitiesUnavailableError";
+  }
+};
+var INITIAL_RETRY_MS = 5e3;
+var MAX_RETRY_MS = 5 * 6e4;
+function readTaxRounding({ connector, context }) {
+  if (context.capabilities) return Promise.resolve(context.capabilities.taxRounding);
+  if (!connector.storeSettings || !connector.capabilities) return Promise.resolve(void 0);
+  const read = connector.capabilities;
+  return Promise.resolve().then(() => read(context)).then(
+    (capabilities) => {
+      if (!capabilities) throw new StoreCapabilitiesUnavailableError();
+      return capabilities.taxRounding;
+    },
+    (cause) => {
+      throw new StoreCapabilitiesUnavailableError(cause);
+    }
+  );
+}
 function useStoreSettings(options) {
   const { connector, context } = options;
   const optionsRef = useRef(options);
   optionsRef.current = options;
   const requestRef = useRef(0);
+  const retryTimerRef = useRef(void 0);
+  const retryDelayRef = useRef(INITIAL_RETRY_MS);
   const [state, setState] = useState(LOADING);
-  const resolve = useCallback2((choice, from) => {
+  const resolve = useCallback2((choice, from, known) => {
     if (from !== void 0 && from !== requestRef.current) return;
+    clearTimeout(retryTimerRef.current);
     const request = ++requestRef.current;
     const current = () => request === requestRef.current;
     setState(LOADING);
-    resolveStoreSettings(optionsRef.current, choice).then(
-      (result) => {
+    const rounding = known ?? readTaxRounding(optionsRef.current);
+    Promise.all([resolveStoreSettings(optionsRef.current, choice), rounding]).then(
+      ([result, taxRounding]) => {
         if (!current()) return;
-        if (result.status === "ready") setState({ state: "ready", settings: result.settings, choice: result.choice });
+        retryDelayRef.current = INITIAL_RETRY_MS;
+        if (result.status === "ready")
+          setState({ state: "ready", settings: taxRounding ? { ...result.settings, taxRounding } : result.settings, choice: result.choice });
         else if (result.status === "choose")
-          setState({ state: "choose", choices: result.choices, initial: result.initial, choose: (pick) => resolve(pick, request) });
+          setState({ state: "choose", choices: result.choices, initial: result.initial, choose: (pick) => resolve(pick, request, rounding) });
         else setState({ state: "unsupported" });
       },
       // A retry keeps the choice that failed: a new pick is saved only once it resolves.
       (error) => {
-        if (current()) setState({ state: "error", error, retry: () => resolve(choice, request) });
+        if (!current()) return;
+        const retry = () => resolve(choice, request);
+        if (error instanceof StoreCapabilitiesUnavailableError) {
+          const delay = retryDelayRef.current;
+          const nextRetryAt = Date.now() + delay;
+          retryDelayRef.current = Math.min(delay * 2, MAX_RETRY_MS);
+          retryTimerRef.current = setTimeout(retry, delay);
+          setState({ state: "error", error, retry, nextRetryAt });
+        } else setState({ state: "error", error, retry });
       }
     );
   }, []);
   useEffect(() => {
     resolve();
     return () => {
+      clearTimeout(retryTimerRef.current);
+      retryDelayRef.current = INITIAL_RETRY_MS;
       requestRef.current += 1;
     };
   }, [connector, context, resolve]);
@@ -397,6 +487,7 @@ function allocateOrderDiscount(lineAmountsMinor, totalMinor) {
 }
 
 // src/order/order-builder.ts
+var perRateGroupWarned = /* @__PURE__ */ new WeakSet();
 var nextId = 0;
 function uid() {
   return `${Date.now()}-${++nextId}`;
@@ -404,12 +495,15 @@ function uid() {
 function roundHalfAway(n) {
   return Math.sign(n) * Math.round(Math.abs(n));
 }
-function sumLines(lines) {
+function sumLines(lines, rounding) {
+  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 : void 0;
   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);
-  const linesTotal = netMinor + roundMicrosToMinor(exclusiveTaxMicros);
+  const taxMinor = roundMicrosToMinor(lineTaxMicros, mode);
+  const linesTotal = netMinor + roundMicrosToMinor(exclusiveTaxMicros, mode);
   return { subtotalMinor: linesTotal - taxMinor, taxMinor, totalMinor: Math.max(0, linesTotal) };
 }
 function toDisplayMode(line, amountMinor, displayInclusive) {
@@ -480,7 +574,11 @@ function createOrderBuilder(options) {
     });
     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);
+    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);
     const taxInclusive = taxContext.pricesIncludeTax;
     const figures = lines.map((li) => {
@@ -558,6 +656,7 @@ function createOrderBuilder(options) {
       changeDueMinor,
       currency,
       pricesIncludeTax: taxContext.pricesIncludeTax,
+      ...taxContext.rounding ? { taxRounding: taxContext.rounding } : {},
       createdAt: now,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -571,7 +670,8 @@ function createOrderBuilder(options) {
     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");
-    const taxRates = input.taxRates ?? [{ ratePpm: taxContext.getTaxRatePpm() }];
+    const code = input.taxRates ? void 0 : taxContext.getTaxRateCode?.(input.taxClass);
+    const taxRates = input.taxRates ?? [{ ...code !== void 0 ? { 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)
@@ -629,7 +729,8 @@ function createOrderBuilder(options) {
         sku: variant?.sku ?? traits.getSku(doc),
         imageUrl: traits.getImageUrl(doc),
         unitPrice,
-        quantity: opts?.quantity
+        quantity: opts?.quantity,
+        taxClass: traits.getTaxClass?.(doc, opts?.variantId)
       });
     },
     updateQuantity(lineId, quantity) {
@@ -711,8 +812,127 @@ function createOrderBuilder(options) {
   };
 }
 
+// src/order/tax-figures.ts
+function taxFiguresForBasket(currency, pricesIncludeTax, lines, rounding) {
+  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, void 0, taxRounding) };
+}
+
 // src/order/order-manager.ts
 import { BehaviorSubject as BehaviorSubject2, map as map2 } from "rxjs";
+
+// src/pos-order/command.ts
+var UnsupportedOrderVersionError = class extends Error {
+  constructor(needed, supported) {
+    super(`This sale needs order.create version ${needed}; the server supports up to ${supported}.`);
+    this.needed = needed;
+    this.supported = supported;
+    this.name = "UnsupportedOrderVersionError";
+  }
+  code = "UNSUPPORTED_ORDER_VERSION";
+};
+var PAYLOAD_STRING_MAX = 255;
+var sendable = (value, max) => typeof value === "string" && value.length > 0 && value.length <= max && !value.includes("\0");
+function customerRefusal(customer) {
+  return customer.email !== void 0 && customer.email !== "" && !sendable(customer.email, 254) ? CUSTOMER_REFUSALS[0] : customer.id !== void 0 && customer.id !== "" && !sendable(customer.id, 64) ? CUSTOMER_REFUSALS[1] : null;
+}
+var CUSTOMER_REFUSALS = ["email", "id"].map((field) => `This customer's ${field} can't be sent to the store, so they weren't added to the sale.`);
+function cutText(text2, max) {
+  const clean = text2.replaceAll("\0", "");
+  if (clean.length <= max) return clean;
+  const high = clean.charCodeAt(max - 2);
+  return `${clean.slice(0, high >= 55296 && high <= 56319 ? max - 2 : max - 1)}\u2026`;
+}
+function netDiscountMinor(line, pricesIncludeTax) {
+  if (!(line.taxInclusive ?? pricesIncludeTax) || line.discountMinor === 0) return line.discountMinor;
+  const ratePpm = line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0);
+  const taxAfter = line.taxLines.reduce((sum, tax) => sum + BigInt(tax.taxMicros), 0n);
+  const taxBefore = taxMicros(line.unitPriceMinor * line.quantity, ratePpm, true);
+  return roundMicrosToMinor(BigInt(line.discountMinor) * MICROS_PER_MINOR - taxBefore + taxAfter);
+}
+function contentVersion(order) {
+  return order.display && order.taxByRate ? 3 : order.lines.reduce((sum, line) => sum + line.discountMinor, 0) > 0 ? 2 : 1;
+}
+function toOrderCreateEnvelope(order, deviceId, attempt2 = 1, options) {
+  const grossMinor = order.lines.reduce((sum, line) => sum + line.discountMinor, 0);
+  const content = contentVersion(order);
+  const cap = options?.maxVersion === void 0 ? order.sentVersion : Math.min(options.maxVersion, order.sentVersion ?? options.maxVersion);
+  if (grossMinor > 0 && cap !== void 0 && cap < 2) throw new UnsupportedOrderVersionError(2, cap);
+  const version = content === 3 && cap !== void 0 && cap >= 4 ? 4 : Math.min(content, cap ?? content);
+  const lineDiscounts = order.lines.map((line) => version === 4 ? netDiscountMinor(line, order.pricesIncludeTax) : line.discountMinor);
+  const discountMinor = lineDiscounts.reduce((sum, discount) => sum + discount, 0);
+  const email = order.customer?.email;
+  const id2 = order.customer?.id;
+  const customerId = typeof id2 === "string" && id2.length > 0 && id2.length <= 64 ? id2 : void 0;
+  const sessionId = order.sessionId ?? order.lateSessionId;
+  return {
+    id: order.commandId,
+    type: "order.create",
+    version,
+    createdAt: order.createdAt,
+    deviceId,
+    attempt: attempt2,
+    payload: {
+      clientOrderId: order.id,
+      createdAt: order.createdAt,
+      currency: order.currency,
+      pricesIncludeTax: order.pricesIncludeTax,
+      lines: order.lines.map((line, i) => ({
+        clientLineId: line.id,
+        variantId: line.variantId ?? line.productId,
+        title: line.name,
+        quantity: line.quantity,
+        unitPriceMinor: line.unitPriceMinor,
+        ...line.taxInclusive !== void 0 ? { taxInclusive: line.taxInclusive } : {},
+        ...lineDiscounts[i] > 0 ? { discountMinor: lineDiscounts[i] } : {}
+      })),
+      payments: order.payments.map((payment) => ({
+        clientPaymentId: payment.id,
+        method: payment.method,
+        amountMinor: payment.amountMinor,
+        ...payment.tenderedMinor !== void 0 ? { tenderedMinor: payment.tenderedMinor } : {},
+        ...payment.changeMinor !== void 0 ? { changeMinor: payment.changeMinor } : {},
+        ...payment.reference !== void 0 ? { reference: payment.reference } : {}
+      })),
+      subtotalMinor: order.subtotalMinor,
+      ...discountMinor > 0 ? { discountMinor } : {},
+      taxMinor: order.taxMinor,
+      totalMinor: order.totalMinor,
+      ...version >= 3 ? {
+        display: { ...order.display, lines: order.display.lines.map(({ lineId, amountMinor, discounts }) => ({
+          clientLineId: lineId,
+          amountMinor,
+          discounts
+        })) },
+        taxByRate: order.taxByRate.map(({ ratePpm, code, netMinor, amountMinor, grossMinor: grossMinor2 }) => ({
+          ratePpm,
+          ...code !== void 0 ? { code } : {},
+          netMinor,
+          taxMinor: amountMinor,
+          grossMinor: grossMinor2
+        }))
+      } : {},
+      customer: version >= 3 ? email || customerId ? { ...email ? { email } : {}, ...customerId ? { customerId } : {} } : null : email ? { email } : null,
+      ...order.registerId !== void 0 ? { registerId: order.registerId } : {},
+      ...order.cashierRef !== void 0 ? { cashierRef: order.cashierRef } : {},
+      ...version >= 3 && typeof sessionId === "string" && sessionId.length > 0 && sessionId.length <= 36 ? { sessionId } : {}
+    }
+  };
+}
+
+// src/order/order-manager.ts
 function createOrderManager(options) {
   const { taxContext, draftsCollection } = options;
   const currency = options.currency.toUpperCase();
@@ -765,7 +985,7 @@ function createOrderManager(options) {
         taxContext,
         id: savedOrder.id
       });
-      if (savedOrder.customer) {
+      if (savedOrder.customer && !customerRefusal(savedOrder.customer)) {
         builder.setCustomer(savedOrder.customer);
       }
       if (savedOrder.note) {
@@ -822,7 +1042,7 @@ function createOrderManager(options) {
 
 // src/receipt/build-receipt-data.ts
 function buildReceiptData(order, config) {
-  const taxLines = taxLinesByRate(order.lineItems, order.taxMinor, config.taxLabels).map(
+  const taxLines = taxLinesByRate(order.lineItems, order.taxMinor, config.taxLabels, order.taxRounding).map(
     ({ label: label2, code, ratePpm, amountMinor }) => ({ label: label2, code, ratePpm, amountMinor })
   );
   let taxSoFar = order.lineItems.reduce(
@@ -836,6 +1056,7 @@ function buildReceiptData(order, config) {
     return li.taxInclusive ? li.netMinor - share : li.netMinor + share;
   });
   const label = (d) => d.label ?? d.couponCode ?? `${d.type} discount`;
+  const customer = order.customer?.name || order.customer?.email;
   return {
     header: {
       storeName: config.storeName,
@@ -843,6 +1064,7 @@ function buildReceiptData(order, config) {
       orderNumber: order.id,
       date: order.createdAt,
       cashier: config.cashier,
+      ...customer ? { customer } : {},
       register: config.register
     },
     lineItems: order.lineItems.map((li, index) => ({
@@ -887,7 +1109,11 @@ function buildReceiptData(order, config) {
 function searchProducts(docs, term, traits) {
   const query = term.trim().toLowerCase();
   if (!query) return docs;
-  const codes = (doc) => [traits.getSku(doc), traits.getBarcode(doc)].filter((code) => Boolean(code)).map((code) => code.toLowerCase());
+  const codes = (doc) => [...new Set([
+    traits.getSku(doc),
+    traits.getBarcode(doc),
+    ...(traits.getVariants?.(doc) ?? []).flatMap((variant) => [variant.sku, variant.barcode])
+  ].filter((code) => Boolean(code)).map((code) => code.toLowerCase()))];
   const exact = docs.filter((doc) => codes(doc).includes(query));
   if (exact.length) return exact;
   const words = query.split(/\s+/);
@@ -913,7 +1139,7 @@ function stockOverlayAsOf$(collection) {
 }
 
 // src/sale/use-sale.ts
-import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { useEffect as useEffect3, useLayoutEffect, useRef as useRef3, useState as useState3 } from "react";
 
 // src/pos-order/uuidv7.ts
 function format(ms, bytes) {
@@ -965,6 +1191,72 @@ function uuidv7(now, randomBytes) {
 }
 
 // src/pos-order/finalize.ts
+import { minorUnitDigits } from "@tallyui/core";
+
+// src/outbox/logger.ts
+var outboxLogger = createLogger("outbox");
+
+// src/pos-order/finalize.ts
+var MESSAGE_NAME_MAX = 61;
+function withSentForm(order, posOrder) {
+  const customer = order.customer && { ...order.customer };
+  if (customer && posOrder.customer?.email === void 0) delete customer.email;
+  if (customer && posOrder.customer?.id === void 0) delete customer.id;
+  return {
+    ...order,
+    customer,
+    lineItems: order.lineItems.map((line, i) => ({ ...line, name: posOrder.lines[i].name })),
+    display: posOrder.display ? {
+      ...order.display,
+      lines: order.display.lines.map((line, i) => ({
+        ...line,
+        discounts: line.discounts.map((discount, j) => ({ ...discount, label: posOrder.display.lines[i].discounts[j].label }))
+      }))
+    } : order.display
+  };
+}
+function freezeSentForm(order) {
+  let changed = false;
+  const lines = order.lines.map((line) => {
+    const name = cutText(line.name, PAYLOAD_STRING_MAX);
+    changed ||= name !== line.name;
+    return { ...line, name };
+  });
+  const display = order.display && { ...order.display, lines: order.display.lines.map((line) => ({
+    ...line,
+    discounts: line.discounts.map((discount) => {
+      if (discount.label === void 0) return discount;
+      const label = cutText(discount.label, PAYLOAD_STRING_MAX);
+      changed ||= label !== discount.label;
+      return { ...discount, label };
+    })
+  })) };
+  const payments = order.payments.map((payment) => {
+    if (payment.reference === void 0) return payment;
+    const reference = cutText(payment.reference, PAYLOAD_STRING_MAX);
+    changed ||= reference !== payment.reference;
+    return { ...payment, reference };
+  });
+  const customer = order.customer && { ...order.customer };
+  const localWarnings = [...order.localWarnings ?? []];
+  for (const [field, max] of [["email", 254], ["id", 64]]) {
+    if (customer && field in customer && !sendable(customer[field], max)) {
+      delete customer[field];
+      changed = true;
+      if (!localWarnings.some((warning) => warning.code === "customer_omitted" && warning.field === field)) localWarnings.push({ code: "customer_omitted", field });
+    }
+  }
+  return changed ? { ...order, lines, payments, customer, ...display ? { display } : {}, ...localWarnings.length ? { localWarnings } : {} } : order;
+}
+function referenceError(label, value) {
+  const reason = referenceReason(value);
+  return reason === "long" ? `${label} is too long (max ${PAYLOAD_STRING_MAX} characters)` : reason === "nul" ? `${label} contains a NUL character` : null;
+}
+function referenceReason(value) {
+  if (value === void 0) return null;
+  if (value.length > PAYLOAD_STRING_MAX) return "long";
+  return value.includes("\0") ? "nul" : null;
+}
 function finalizeOrder(order, options = {}) {
   if (!order.lineItems.length) throw new Error("finalize: no lines");
   if (order.discountMinor < 0 || order.lineItems.some((line) => line.discountMinor < 0) || order.discounts.some((d) => d.amountMinor < 0)) {
@@ -983,6 +1275,24 @@ function finalizeOrder(order, options = {}) {
   let change = order.paidMinor - order.totalMinor;
   const cash = order.payments.reduce((sum, p) => sum + (p.method === "cash" ? p.amountMinor : 0), 0);
   if (change > cash) throw new Error("finalize: change exceeds cash");
+  const v3 = (options.capabilities?.orderCreate ?? 1) >= 3;
+  const references = [
+    ["registerId", options.registerId],
+    ["cashierRef", options.cashierRef],
+    ...order.lineItems.flatMap((line, i) => {
+      const name = `"${cutText(line.name, MESSAGE_NAME_MAX)}"`;
+      return [
+        line.variantId !== void 0 ? [`${name}: the variant id`, line.variantId] : [`${name}: the product id`, line.productId],
+        ...(v3 ? order.display.lines[i]?.discounts ?? [] : []).map((d) => [`${name}: the discount id`, d.discountId]),
+        ...(v3 ? line.taxLines : []).map((tax) => [`${name}: the tax code`, tax.code])
+      ];
+    }),
+    ...order.payments.map((payment) => [`the ${payment.method} payment's reference`, payment.reference])
+  ];
+  for (const [field, value] of references) {
+    const message = referenceError(field, value);
+    if (message) throw new Error(`finalize: ${message}`);
+  }
   const newId = options.newId ?? uuidv7;
   const id2 = newId();
   const lines = order.lineItems.map((line) => ({
@@ -1004,6 +1314,18 @@ function finalizeOrder(order, options = {}) {
     amountMinor: payment.amountMinor,
     ...payment.reference !== void 0 ? { reference: payment.reference } : {}
   }));
+  const localWarnings = options.localWarnings?.flatMap((warning) => {
+    if (warning.code !== "payment_reference_dropped") return [{ ...warning }];
+    const index = order.payments.findIndex((payment) => payment.id === warning.paymentId);
+    if (index === -1) {
+      try {
+        outboxLogger.warn("finalize: dropped a localWarnings entry naming an unknown payment", { orderId: id2, paymentId: warning.paymentId });
+      } catch {
+      }
+      return [];
+    }
+    return [{ ...warning, paymentId: payments[index].id }];
+  });
   for (let i = payments.length - 1; i >= 0; i--) {
     const payment = payments[i];
     if (payment.method !== "cash") continue;
@@ -1015,8 +1337,44 @@ function finalizeOrder(order, options = {}) {
   if (payments.reduce((sum, p) => sum + p.amountMinor, 0) !== order.totalMinor) {
     throw new Error("finalize: payments do not reconcile");
   }
+  let display;
+  let taxByRate;
+  if ((options.capabilities?.orderCreate ?? 1) >= 3) {
+    if (order.display.lines.length !== order.lineItems.length || order.display.lines.some((line, i) => line.lineId !== order.lineItems[i].id)) {
+      throw new Error("finalize: display lines do not match the order lines");
+    }
+    display = {
+      currency: order.currency,
+      exponent: minorUnitDigits(order.currency),
+      ...order.display,
+      lines: order.display.lines.map((line, i) => ({
+        lineId: lines[i].id,
+        amountMinor: line.amountMinor,
+        discounts: line.discounts.map(({ discountId, label, amountMinor }) => ({
+          discountId,
+          ...label !== void 0 ? { label } : {},
+          amountMinor
+        }))
+      }))
+    };
+    taxByRate = taxLinesByRate(order.lineItems, order.taxMinor, void 0, order.taxRounding).map(({ ratePpm, code, netMinor, amountMinor }) => ({
+      ratePpm,
+      ...code !== void 0 ? { code } : {},
+      netMinor,
+      amountMinor,
+      grossMinor: netMinor + amountMinor
+    }));
+    if (display.totalMinor !== order.totalMinor || display.taxMinor !== order.taxMinor || display.taxInclusive !== order.pricesIncludeTax) {
+      throw new Error("finalize: display does not match the order");
+    }
+    if (taxByRate.reduce((sum, rate) => sum + rate.amountMinor, 0) !== order.taxMinor) {
+      throw new Error("finalize: tax by rate does not sum to the order tax");
+    }
+  }
+  const rounding = order.taxRounding ?? DEFAULT_TAX_ROUNDING;
+  const taxRounding = rounding.granularity === "custom" ? { granularity: "custom" } : { granularity: rounding.granularity, mode: rounding.mode };
   const now = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
-  return {
+  return freezeSentForm({
     id: id2,
     createdAt: now,
     updatedAt: now,
@@ -1030,6 +1388,8 @@ function finalizeOrder(order, options = {}) {
     discountMinor: order.discountMinor,
     taxMinor: order.taxMinor,
     totalMinor: order.totalMinor,
+    taxRounding,
+    ...display && taxByRate ? { display, taxByRate } : {},
     customer: order.customer ? {
       id: order.customer.id,
       name: order.customer.name,
@@ -1037,58 +1397,16 @@ function finalizeOrder(order, options = {}) {
     } : null,
     ...order.note ? { note: order.note } : {},
     ...options.registerId !== void 0 ? { registerId: options.registerId } : {},
-    ...options.cashierRef !== void 0 ? { cashierRef: options.cashierRef } : {}
-  };
-}
-
-// src/pos-order/command.ts
-function toOrderCreateEnvelope(order, deviceId, attempt2 = 1) {
-  const discountMinor = order.lines.reduce((sum, line) => sum + line.discountMinor, 0);
-  return {
-    id: order.commandId,
-    type: "order.create",
-    version: discountMinor > 0 ? 2 : 1,
-    createdAt: order.createdAt,
-    deviceId,
-    attempt: attempt2,
-    payload: {
-      clientOrderId: order.id,
-      createdAt: order.createdAt,
-      currency: order.currency,
-      pricesIncludeTax: order.pricesIncludeTax,
-      lines: order.lines.map((line) => ({
-        clientLineId: line.id,
-        variantId: line.variantId ?? line.productId,
-        title: line.name,
-        quantity: line.quantity,
-        unitPriceMinor: line.unitPriceMinor,
-        ...line.taxInclusive !== void 0 ? { taxInclusive: line.taxInclusive } : {},
-        ...line.discountMinor > 0 ? { discountMinor: line.discountMinor } : {}
-      })),
-      payments: order.payments.map((payment) => ({
-        clientPaymentId: payment.id,
-        method: payment.method,
-        amountMinor: payment.amountMinor,
-        ...payment.tenderedMinor !== void 0 ? { tenderedMinor: payment.tenderedMinor } : {},
-        ...payment.changeMinor !== void 0 ? { changeMinor: payment.changeMinor } : {},
-        ...payment.reference !== void 0 ? { reference: payment.reference } : {}
-      })),
-      subtotalMinor: order.subtotalMinor,
-      ...discountMinor > 0 ? { discountMinor } : {},
-      taxMinor: order.taxMinor,
-      totalMinor: order.totalMinor,
-      customer: order.customer?.email ? { email: order.customer.email } : null,
-      ...order.registerId !== void 0 ? { registerId: order.registerId } : {},
-      ...order.cashierRef !== void 0 ? { cashierRef: order.cashierRef } : {}
-    }
-  };
+    ...options.cashierRef !== void 0 ? { cashierRef: options.cashierRef } : {},
+    ...localWarnings?.length ? { localWarnings } : {}
+  });
 }
 
 // src/pos-order/schema.ts
 import { addRxPlugin } from "rxdb";
 import { RxDBMigrationSchemaPlugin } from "rxdb/plugins/migration-schema";
 var posOrderSchema = {
-  version: 2,
+  version: 6,
   primaryKey: "id",
   type: "object",
   additionalProperties: false,
@@ -1106,7 +1424,7 @@ var posOrderSchema = {
     syncStatus: { type: "string", enum: ["pending", "applied", "rejected"], maxLength: 10 },
     note: { type: "string" },
     registerId: { type: "string" },
-    sessionId: { type: "string" },
+    sessionId: { type: "string", maxLength: 36 },
     cashierRef: { type: "string" },
     lines: { type: "array", items: {
       type: "object",
@@ -1153,7 +1471,23 @@ var posOrderSchema = {
       additionalProperties: true
     } },
     error: { type: "object", properties: { code: { type: "string" }, message: { type: "string" } }, required: ["code", "message"] },
+    localWarnings: { type: "array", items: { type: "object", additionalProperties: false, properties: {
+      code: { type: "string", maxLength: 64 },
+      field: { type: "string", maxLength: 16 },
+      paymentId: { type: "string", maxLength: 36 }
+    }, required: ["code"] } },
+    serverFailures: { type: "object", additionalProperties: false, properties: {
+      since: { type: "integer", minimum: 0 },
+      reason: { type: "string", maxLength: 64 },
+      isolated: { type: "boolean" }
+    }, required: ["since", "reason", "isolated"] },
     lateSessionId: { type: "string" },
+    taxRounding: { type: "object", additionalProperties: false, properties: {
+      granularity: { type: "string", enum: ["per_order", "per_line_items", "per_rate_group_items", "custom"] },
+      mode: { type: "string", enum: ["half_away_from_zero", "half_up"] }
+    }, required: ["granularity"] },
+    sentVersion: { type: "integer", minimum: 1, maximum: 4 },
+    downgradedFrom: { type: "integer", minimum: 1, maximum: 4 },
     // The nested objects are closed too: loosening a schema later is free, tightening one costs a migration.
     display: { type: "object", additionalProperties: false, properties: {
       currency: { type: "string" },
@@ -1208,14 +1542,26 @@ var posOrderSchema = {
     "customer",
     "syncStatus",
     "commandId",
-    "updatedAt"
+    "updatedAt",
+    "taxRounding"
   ],
-  indexes: ["createdAt", "syncStatus", ["syncStatus", "createdAt"]]
+  indexes: ["createdAt", "syncStatus", ["syncStatus", "createdAt"], "sessionId"]
 };
 function posOrderCollection() {
   addRxPlugin(RxDBMigrationSchemaPlugin);
   const identity2 = (doc) => doc;
-  return { schema: posOrderSchema, migrationStrategies: { 1: identity2, 2: identity2 } };
+  const recordSent = (doc) => {
+    doc.sentVersion ??= contentVersion(doc);
+    return doc;
+  };
+  const recordRounding = (doc) => {
+    doc.taxRounding ??= { ...DEFAULT_TAX_ROUNDING };
+    return doc;
+  };
+  return {
+    schema: posOrderSchema,
+    migrationStrategies: { 1: identity2, 2: identity2, 3: identity2, 4: identity2, 5: recordSent, 6: recordRounding }
+  };
 }
 
 // src/pos-order/open.ts
@@ -1253,9 +1599,10 @@ function waitWithTimeout(promise, ms) {
     });
   });
 }
-async function writeOverStaleCopies(collection, from, to) {
+async function writeOverStaleCopies(collection, from, to, stopIfClosing) {
   const handler = rxStorageInstanceToReplicationHandler(to, defaultConflictHandler, collection.database.token, true);
   for (let page = await getChangedDocumentsSince(from, 200); page.documents.length > 0; page = await getChangedDocumentsSince(from, 200, page.checkpoint)) {
+    stopIfClosing();
     const copies = new Map((await to.findDocumentsById(page.documents.map((doc) => doc.id), false)).map((copy) => [copy.id, copy]));
     const rows = await Promise.all(page.documents.filter((doc) => copies.has(doc.id) && !doc._deleted).map(async (doc) => ({ assumedMasterState: copies.get(doc.id), newDocumentState: await migrateDocumentData(collection, from.schema.version, doc) })));
     const stale = rows.filter((row) => row.newDocumentState && !deepEqual(row.assumedMasterState, row.newDocumentState));
@@ -1276,7 +1623,8 @@ async function addPosOrderCollection(db, closeWaitMs = POS_ORDER_MIGRATION_CLOSE
   return opening;
 }
 async function openPosOrders(db, previous) {
-  const closing = () => closedUnderOpen.has(db) || db.closed;
+  let cancelled = false;
+  const closing = () => cancelled || closedUnderOpen.has(db) || db.closed;
   const stopIfClosing = () => {
     if (closing()) throw new PosOrderOpenClosedError(db.name);
   };
@@ -1286,7 +1634,11 @@ async function openPosOrders(db, previous) {
     stopIfClosing();
     const mustMigrate = await state.mustMigrate;
     stopIfClosing();
-    if (!mustMigrate) return collection;
+    if (!mustMigrate) {
+      await state.startMigration();
+      stopIfClosing();
+      return collection;
+    }
     await previous;
     stopIfClosing();
     await state.updateStatus((status2) => {
@@ -1310,9 +1662,18 @@ async function openPosOrders(db, previous) {
     await (closing() ? checkpoint.close() : checkpoint.remove());
     stopIfClosing();
     const settled = new Subject();
+    let inFlight = 0;
+    let drained;
+    const track = (result) => {
+      if (!(result instanceof Promise)) return result;
+      inFlight++;
+      return result.finally(() => {
+        if (--inFlight === 0) drained?.();
+      });
+    };
     const gate = (target, closed) => new Proxy(target, { get: (t, key) => {
       const value = Reflect.get(t, key);
-      return typeof value !== "function" ? value : (...args) => closing() && (key === "bulkWrite" || key === "findDocumentsById") ? closed(key, args[0]) : value.apply(t, args);
+      return typeof value !== "function" ? value : (...args) => closing() && (key === "bulkWrite" || key === "findDocumentsById") ? closed(key, args[0]) : track(value.apply(t, args));
     } });
     const internalStore = gate(db.internalStore, async (key, first) => {
       const ids = key === "bulkWrite" ? first.map((row) => row.document.id) : first;
@@ -1325,14 +1686,33 @@ async function openPosOrders(db, previous) {
     state.database = new Proxy(db, { get: (target, key) => key === "internalStore" ? internalStore : Reflect.get(target, key) });
     const migrateStorage = state.migrateStorage.bind(state);
     state.migrateStorage = async (from, current, batchSize) => {
+      stopIfClosing();
       const to = gate(current, () => Promise.reject(new PosOrderOpenClosedError(db.name)));
-      if (from.collectionName === collection.name) await writeOverStaleCopies(collection, from, to);
+      if (from.collectionName === collection.name) await writeOverStaleCopies(collection, from, to, stopIfClosing);
+      stopIfClosing();
       return migrateStorage(new Proxy(from, { get: (target, key) => {
         const value = key === "changeStream" ? () => target.changeStream().pipe(takeUntil(settled)) : Reflect.get(target, key);
         return typeof value === "function" ? value.bind(target) : value;
       } }), to, batchSize);
     };
-    await state.startMigration().finally(() => settled.next());
+    let running = true;
+    let onCancel;
+    const cancelledRun = new Promise((resolve) => {
+      onCancel = resolve;
+    });
+    const cancel = state.cancel.bind(state);
+    state.cancel = () => {
+      if (running) {
+        cancelled = true;
+        if (inFlight === 0) onCancel();
+        else drained = onCancel;
+      }
+      return cancel();
+    };
+    await Promise.race([state.startMigration(), cancelledRun]).finally(() => {
+      running = false;
+      settled.next();
+    });
     stopIfClosing();
     const status = (await getSingleDocument(db.internalStore, state.statusDocId))?.data;
     stopIfClosing();
@@ -1363,8 +1743,9 @@ function getDeviceId(storage, key) {
 }
 
 // src/pos-order/needs-attention.ts
-function needsAttention(orders) {
-  return orders.filter((order) => order.syncStatus === "rejected" || order.syncStatus === "applied" && !!order.warnings?.length || order.lateSessionId !== void 0).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+import { knownWarnings } from "@tallyui/core";
+function needsAttention(orders, options = {}) {
+  return orders.filter((order) => order.syncStatus === "rejected" || (order.localWarnings?.length ?? 0) > 0 || order.syncStatus === "applied" && knownWarnings(order.warnings).length > 0 || order.lateSessionId !== void 0 || order.syncStatus === "pending" && options.stuckCommandIds?.includes(order.commandId) === true).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }
 
 // src/pos-order/same-sale.ts
@@ -1586,6 +1967,7 @@ var closureSchema = {
 // src/register/register-document.ts
 import { map as map4 } from "rxjs";
 var REGISTER = "register";
+var MAX_REGISTER_ID_LENGTH = 36;
 function mintUuid() {
   const id2 = globalThis.crypto?.randomUUID?.();
   if (id2) return id2;
@@ -1637,7 +2019,16 @@ async function readBoundRegister(host, storeKey) {
   const id2 = getBoundRegisterId(register, storeKey);
   return id2 ? { id: id2, name: register?.stores[storeKey]?.register_name ?? "" } : null;
 }
-function bindRegister(host, storeKey, register) {
+var RegisterIdInvalidError = class extends Error {
+  constructor() {
+    super("register_id_invalid");
+    this.name = "RegisterIdInvalidError";
+  }
+};
+async function bindRegister(host, storeKey, register) {
+  if (typeof register.id === "string" && (register.id.length === 0 || register.id.length > MAX_REGISTER_ID_LENGTH)) {
+    throw new RegisterIdInvalidError();
+  }
   return modifyStore(host, storeKey, (store) => ({
     ...store ?? { sale_counter: 0 },
     register_id: register.id,
@@ -1659,6 +2050,16 @@ function withRegister(store, registerId, bucket) {
   const base = store ?? { sale_counter: 0 };
   return { ...base, registers: { ...base.registers, [registerId]: bucket } };
 }
+async function markCommandsSince(host, storeKey, registerId, now) {
+  let since = now;
+  await modifyStore(host, storeKey, (store) => {
+    const register = store?.registers?.[registerId] ?? {};
+    since = register.commands_since ?? now;
+    if (register.commands_since !== void 0) return void 0;
+    return withRegister(store, registerId, { ...register, commands_since: since });
+  });
+  return since;
+}
 async function mintClosureNumber(host, storeKey, registerId, closure) {
   let number = 0;
   await modifyStore(host, storeKey, (store) => {
@@ -1802,6 +2203,18 @@ var RegisterSessionClosedError = class extends Error {
     this.name = "RegisterSessionClosedError";
   }
 };
+var RegisterMovementAmountError = class extends Error {
+  constructor(type, amountMinor) {
+    super(`movement_amount_invalid:${type}:${amountMinor}`);
+    this.name = "RegisterMovementAmountError";
+  }
+};
+var RegisterMovementReasonError = class extends Error {
+  constructor() {
+    super("movement_reason_invalid");
+    this.name = "RegisterMovementReasonError";
+  }
+};
 var RegisterMovementStrandedError = class extends Error {
   id;
   session_id;
@@ -1933,13 +2346,16 @@ async function closeSession(sessions, id2, input) {
   });
 }
 async function recordMovement(sessions, movements, closures, input) {
+  if (!Number.isSafeInteger(input.amountMinor) || (input.type === "paid_in" || input.type === "paid_out") && input.amountMinor <= 0 || input.type === "no_sale" && input.amountMinor !== 0) throw new RegisterMovementAmountError(input.type, input.amountMinor);
+  const reasonLength = input.reason.trim().length;
+  if (reasonLength === 0 || reasonLength > MAX_REASON_LENGTH) throw new RegisterMovementReasonError();
   await requireLiveSession(sessions, input.sessionId);
   const row = await movements.insert({
     id: mintUuid(),
     session_id: input.sessionId,
     type: input.type,
     amountMinor: input.amountMinor,
-    reason: input.reason,
+    reason: input.reason.trim(),
     created_by: input.actor,
     created_at_gmt: (/* @__PURE__ */ new Date()).toISOString()
   });
@@ -2041,9 +2457,13 @@ async function writeClosure({
     payment_methods[method] = { sales_minor: (payment_methods[method]?.sales_minor ?? 0) + row2.amountMinor, refunds_minor: 0 };
   }
   const taxRates = /* @__PURE__ */ new Map();
+  const roundings = /* @__PURE__ */ new Set();
   for (const order of bound) {
+    const recorded = order.taxRounding ?? DEFAULT_TAX_ROUNDING;
+    const { granularity, mode } = recorded.granularity === "custom" ? DEFAULT_TAX_ROUNDING : recorded;
+    roundings.add(`${granularity} ${mode}`);
     const lines = order.lines.map((line) => ({ ...line, taxInclusive: line.taxInclusive ?? order.pricesIncludeTax }));
-    for (const { ratePpm, netMinor, amountMinor } of taxLinesByRate(lines, order.taxMinor)) {
+    for (const { ratePpm, netMinor, amountMinor } of taxLinesByRate(lines, order.taxMinor, void 0, order.taxRounding)) {
       const existing2 = taxRates.get(String(ratePpm));
       taxRates.set(String(ratePpm), {
         ratePpm,
@@ -2089,6 +2509,8 @@ async function writeClosure({
           { name: `Tax ${ratePpm / 1e4}%`, net_minor, tax_minor, gross_minor: net_minor + tax_minor }
         ])
       ),
+      // The session's sales used more than one tax rounding (#287): the Z report says so.
+      ...roundings.size > 1 ? { tax_rounding_mixed: true } : {},
       opening_float: {
         expected_minor: session.expected_float_minor ?? null,
         counted_minor: session.counted_float_minor,
@@ -2311,6 +2733,7 @@ function selectClosureRows(rows, scope, timezone) {
 }
 
 // src/register/closure-document.ts
+var TAX_ROUNDING_MIXED_NOTE = "This register's sales used more than one tax rounding method. Each sale's tax is as its receipt showed.";
 var decimalMap = (minor2, exponent) => Object.fromEntries(Object.entries(minor2).map(([key, value]) => [key, minorToDecimal(value, exponent)]));
 function decimalizeBreakdowns(breakdowns, exponent) {
   const dec = (m) => typeof m === "number" ? minorToDecimal(m, exponent) : m;
@@ -2412,6 +2835,7 @@ function envelope(row, context, xreport = false) {
       ...Object.fromEntries(
         ["payment_methods", "tax_rates", "movements"].map((key) => [`has_${key}`, Object.keys(breakdowns[key] ?? {}).length > 0])
       ),
+      ...breakdowns.tax_rounding_mixed === true ? { tax_rounding_note: TAX_ROUNDING_MIXED_NOTE } : {},
       ...money(row, ["period_sales_total", "period_refunds_total", "perpetual_sales_total", "perpetual_refunds_total", "unsynced_total"]),
       opened_at_gmt: row.opened_at,
       opened_by: breakdowns.opened_by ?? null,
@@ -2530,6 +2954,155 @@ function buildXReportDocument(session, context) {
 // src/register/use-register-session.ts
 import { useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
 import { combineLatest, map as map5, of, switchMap } from "rxjs";
+
+// src/register/register-commands.ts
+var registerCommandsLogger = createLogger("register-commands");
+var registerCommandSchema = {
+  title: "Register commands",
+  version: 0,
+  primaryKey: "key",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    key: { type: "string", maxLength: 100 },
+    registerId: { type: "string", maxLength: 36 },
+    seq: { type: "integer", minimum: 0, maximum: 1e15, multipleOf: 1 },
+    commandId: { type: "string" },
+    type: { type: "string" },
+    version: { type: "integer" },
+    payload: { type: "object", additionalProperties: true },
+    createdAt: { type: "string" },
+    updatedAt: { type: "string" },
+    syncStatus: { type: "string", enum: ["pending", "applied", "rejected"], maxLength: 10 },
+    error: { type: "object", properties: {
+      code: { type: "string" },
+      message: { type: "string" },
+      data: { type: "object", additionalProperties: true }
+    }, required: ["code", "message"], additionalProperties: false },
+    result: { type: "object", additionalProperties: true }
+  },
+  required: ["key", "registerId", "seq", "commandId", "type", "version", "payload", "createdAt", "syncStatus", "updatedAt"],
+  indexes: [["registerId", "seq"], ["syncStatus", "registerId", "seq"]]
+};
+var registerCommandCollection = () => ({ schema: registerCommandSchema });
+function sessionOpenCommand(s) {
+  return { key: `session.open:${s.id}`, type: "register.session.open", version: 1, payload: {
+    sessionId: s.id,
+    registerId: s.register_id,
+    openedAt: s.opened_at_gmt,
+    countedFloatMinor: s.counted_float_minor,
+    ...s.store_key == null ? {} : { storeKey: s.store_key },
+    ...s.business_day == null ? {} : { businessDay: s.business_day },
+    ...s.opened_by == null ? {} : { openedBy: s.opened_by },
+    ...s.expected_float_minor == null ? {} : { expectedFloatMinor: s.expected_float_minor },
+    ...s.opening_variance_minor == null ? {} : { openingVarianceMinor: s.opening_variance_minor }
+  } };
+}
+function sessionTransitionCommand(s) {
+  return { key: `session.transition:${s.id}:${s.status}:${s.status_at}`, type: "register.session.transition", version: 1, payload: {
+    sessionId: s.id,
+    status: s.status,
+    at: s.status_at,
+    ...s.status !== "closed" || s.counted == null ? {} : { counted: s.counted },
+    ...s.status !== "closed" || s.closed_by == null ? {} : { closedBy: s.closed_by },
+    ...s.status !== "closed" || s.approved_by == null ? {} : { approvedBy: s.approved_by }
+  } };
+}
+function movementCommand(m) {
+  const common = {
+    movementId: m.id,
+    sessionId: m.session_id,
+    createdAt: m.created_at_gmt,
+    ...m.created_by == null ? {} : { createdBy: m.created_by }
+  };
+  return m.type === "void" ? {
+    key: `movement.void:${m.id}`,
+    type: "register.movement.void",
+    version: 1,
+    payload: { ...common, voids: m.voids }
+  } : {
+    key: `movement.record:${m.id}`,
+    type: "register.movement.record",
+    version: 1,
+    payload: { ...common, type: m.type, amountMinor: m.amountMinor, reason: m.reason }
+  };
+}
+function closureCommand(c) {
+  return { key: `closure.submit:${c.id}`, type: "register.closure.submit", version: 1, payload: {
+    closureId: c.id,
+    sessionId: c.session_id,
+    registerId: c.register_id,
+    number: c.number,
+    openedAt: c.opened_at,
+    closedAt: c.closed_at,
+    ...c.business_day == null ? {} : { businessDay: c.business_day },
+    ...c.closed_by == null ? {} : { closedBy: c.closed_by },
+    ...typeof c.breakdowns.approved_by === "string" && c.breakdowns.approved_by ? { approvedBy: c.breakdowns.approved_by } : {},
+    tillExpected: c.till_expected,
+    counted: c.counted,
+    periodSalesTotalMinor: c.period_sales_total_minor,
+    periodRefundsTotalMinor: c.period_refunds_total_minor,
+    perpetualSalesTotalMinor: c.perpetual_sales_total_minor,
+    perpetualRefundsTotalMinor: c.perpetual_refunds_total_minor,
+    unsyncedCount: c.unsynced_count,
+    unsyncedTotalMinor: c.unsynced_total_minor,
+    softwareVersion: c.software_version,
+    orderIds: c.order_ids,
+    movementIds: c.movement_ids
+  } };
+}
+var chains = /* @__PURE__ */ new WeakMap();
+function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed }) {
+  let registers = chains.get(commands);
+  if (!registers) chains.set(commands, registers = /* @__PURE__ */ new Map());
+  const run = (registers.get(registerId) ?? Promise.resolve()).then(async () => {
+    const since = await markCommandsSince(host, storeKey, registerId, now ?? (/* @__PURE__ */ new Date()).toISOString());
+    const [highest] = await readFresh(commands, { selector: { registerId }, sort: [{ seq: "desc" }], limit: 1 });
+    let seq = highest?.seq ?? 0;
+    const transitioned = new Set((await readFresh(commands, { selector: { registerId, type: "register.session.transition" } })).map(({ payload }) => payload.sessionId));
+    const rows = await readFresh(sessions, { selector: { register_id: registerId } });
+    const complete = new Set((await commands.storageInstance.findDocumentsById(rows.flatMap((session) => [`session.open:${session.id}`, ...session.status === "closed" && session.closure_id ? [`closure.submit:${session.closure_id}`] : []]), false)).map(({ key }) => key));
+    const facts = await Promise.all(rows.filter((session) => session.status !== "closed" || (session.status_at == null || session.status_at >= since || complete.has(`session.open:${session.id}`)) && !complete.has(`closure.submit:${session.closure_id}`)).map(async (session) => {
+      const [entries, closureRows] = await Promise.all([
+        readFresh(movements, { selector: { session_id: session.id } }),
+        session.closure_id ? closures.storageInstance.findDocumentsById([session.closure_id], false) : Promise.resolve([])
+      ]);
+      const events = (observed ?? []).filter((row) => row.id === session.id && !transitioned.has(session.id) && row.status !== session.status && row.status !== "closed").flatMap((row) => row.status_at == null ? [] : [sessionTransitionCommand({ ...row, status_at: row.status_at })]);
+      events.push(
+        ...entries.filter((entry) => entry.type !== "void").map(movementCommand),
+        ...entries.filter((entry) => entry.type === "void").map(movementCommand)
+      );
+      if (session.status_at != null) events.push(sessionTransitionCommand({ ...session, status_at: session.status_at }));
+      return { session, number: closureRows[0]?.number, built: [
+        sessionOpenCommand(session),
+        ...events,
+        ...closureRows.map((closure) => closureCommand(closure))
+      ] };
+    }));
+    facts.sort((a, b) => Number(a.session.status !== "closed") - Number(b.session.status !== "closed") || (a.number ?? Infinity) - (b.number ?? Infinity) || a.session.id.localeCompare(b.session.id));
+    const existing = new Set((await commands.storageInstance.findDocumentsById(facts.flatMap(({ built }) => built.map(({ key }) => key)), false)).map(({ key }) => key));
+    const appended = [];
+    for (const { built } of facts) {
+      for (const command of built) {
+        if (existing.has(command.key)) continue;
+        seq++;
+        const at2 = now ?? (/* @__PURE__ */ new Date()).toISOString();
+        try {
+          await commands.insert({ ...command, registerId, seq, commandId: uuidv7(), createdAt: at2, updatedAt: at2, syncStatus: "pending" });
+          appended.push(command.key);
+        } catch (error) {
+          if (error?.code !== "CONFLICT") throw error;
+        }
+        existing.add(command.key);
+      }
+    }
+    return appended;
+  });
+  registers.set(registerId, run.then(() => void 0, () => void 0));
+  return run;
+}
+
+// src/register/use-register-session.ts
 var RegisterTenderInProgressError = class extends Error {
   constructor() {
     super("Finish or cancel the sale in progress first.");
@@ -2581,6 +3154,25 @@ function ledgerRows(orders) {
 }
 function useRegisterSession(options) {
   const { sessions, movements, closures, orders, register, storeKey, registerId, enabled, actor, timezone, tenderInProgress, expectedCloseTime, labels } = options;
+  const { commands } = options;
+  const commandEnabled = (options.capabilities?.register ?? 0) >= 1;
+  const commandTarget = useMemo3(
+    () => enabled && commandEnabled && commands && sessions && movements && closures && register && registerId ? { commands, sessions, movements, closures, host: register, storeKey, registerId } : null,
+    [enabled, commandEnabled, commands, sessions, movements, closures, register, storeKey, registerId]
+  );
+  const commandTargetRef = useRef2(commandTarget);
+  commandTargetRef.current = commandTarget;
+  const reconcile = (row) => {
+    const target = commandTargetRef.current;
+    if (!target) return;
+    void reconcileRegisterCommands({ ...target, observed: row ? [row] : void 0 }).catch((error) => {
+      try {
+        registerCommandsLogger.error("Register command reconcile failed", { context: { registerId: target.registerId, error: String(error) } });
+      } catch {
+      }
+    });
+  };
+  useEffect2(reconcile, [commandTarget]);
   const source = useMemo3(() => {
     if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register) return null;
     return combineLatest([
@@ -2733,18 +3325,29 @@ function useRegisterSession(options) {
           return await run;
         } finally {
           openingByRegister.delete(key);
+          reconcile();
         }
       },
       startCounting: async () => {
-        refuseDuringTender();
-        const row = await startCounting(live().sessions, current().id);
-        recordRegisterFact({ kind: "counting-started", actor, sessionId: row.id, registerId: row.register_id });
-        return row;
+        let row;
+        try {
+          refuseDuringTender();
+          row = await startCounting(live().sessions, current().id);
+          recordRegisterFact({ kind: "counting-started", actor, sessionId: row.id, registerId: row.register_id });
+          return row;
+        } finally {
+          reconcile(row?.toJSON());
+        }
       },
       backToSelling: async () => {
-        const row = await backToSelling(live().sessions, current().id);
-        recordRegisterFact({ kind: "counting-abandoned", actor, sessionId: row.id, registerId: row.register_id });
-        return row;
+        let row;
+        try {
+          row = await backToSelling(live().sessions, current().id);
+          recordRegisterFact({ kind: "counting-abandoned", actor, sessionId: row.id, registerId: row.register_id });
+          return row;
+        } finally {
+          reconcile(row?.toJSON());
+        }
       },
       /**
        * `counted` maps each tender to its counted minor units. An interrupted close resumes with
@@ -2821,38 +3424,47 @@ function useRegisterSession(options) {
         } finally {
           closingByRegister.delete(key);
           notifyClosing();
+          reconcile();
         }
       },
       recordMovement: async (input) => {
-        const { sessions: sessions2, movements: movements2, closures: closures2, registerId: registerId2 } = live();
-        const sessionId = await requireOpen();
-        const row = await recordMovement(sessions2, movements2, closures2, { ...input, sessionId, actor: actor.id });
-        recordRegisterFact({
-          kind: "movement-recorded",
-          actor,
-          sessionId: row.session_id,
-          registerId: registerId2,
-          movementId: row.id,
-          movementType: row.type,
-          amount: row.amountMinor
-        });
-        return row;
+        try {
+          const { sessions: sessions2, movements: movements2, closures: closures2, registerId: registerId2 } = live();
+          const sessionId = await requireOpen();
+          const row = await recordMovement(sessions2, movements2, closures2, { ...input, sessionId, actor: actor.id });
+          recordRegisterFact({
+            kind: "movement-recorded",
+            actor,
+            sessionId: row.session_id,
+            registerId: registerId2,
+            movementId: row.id,
+            movementType: row.type,
+            amount: row.amountMinor
+          });
+          return row;
+        } finally {
+          reconcile();
+        }
       },
       voidMovement: async (id2) => {
-        const { sessions: sessions2, movements: movements2, closures: closures2, registerId: registerId2 } = live();
-        await requireOpen();
-        const row = await voidMovement(sessions2, movements2, id2, actor.id, closures2);
-        recordRegisterFact({
-          kind: "movement-voided",
-          actor,
-          sessionId: row.session_id,
-          registerId: registerId2,
-          movementId: row.id,
-          movementType: row.type,
-          amount: row.amountMinor,
-          voids: id2
-        });
-        return row;
+        try {
+          const { sessions: sessions2, movements: movements2, closures: closures2, registerId: registerId2 } = live();
+          await requireOpen();
+          const row = await voidMovement(sessions2, movements2, id2, actor.id, closures2);
+          recordRegisterFact({
+            kind: "movement-voided",
+            actor,
+            sessionId: row.session_id,
+            registerId: registerId2,
+            movementId: row.id,
+            movementType: row.type,
+            amount: row.amountMinor,
+            voids: id2
+          });
+          return row;
+        } finally {
+          reconcile();
+        }
       }
     }
   };
@@ -2878,7 +3490,8 @@ function addEntryToCart(builder, entry, traits, currency) {
     name,
     sku: variant.sku ?? "",
     imageUrl: traits.getImageUrl?.(product),
-    unitPrice
+    unitPrice,
+    taxClass: traits.getTaxClass?.(product, variant.id)
   });
 }
 
@@ -2890,13 +3503,17 @@ var HUNG_SAVE_CHECK_MS = 5e3;
 function useSale(settings, opts) {
   const taxContext = useTax();
   const madeWith = useRef3({ taxContext, currency: settings.currency });
-  const [builder, setBuilder] = useState3(() => createOrderBuilder({ currency: settings.currency, taxContext }));
-  const [order, setOrder] = useState3(() => builder.getSnapshot());
+  const [rendered, setBuilder] = useState3(() => createOrderBuilder({ currency: settings.currency, taxContext }));
+  const builderNow = useRef3(rendered);
+  const [order, setOrder] = useState3(() => rendered.getSnapshot());
   const [stage, setStage] = useState3({ kind: "cart" });
-  const [error, setError] = useState3(null);
+  const [saleError, setError] = useState3(null);
+  const configError = referenceError("cashierRef", opts.cashierRef) ?? referenceError("registerId", opts.registerId);
   const pending = useRef3(null);
   const [saving, setSaving] = useState3(false);
+  const error = saving && saleError ? saleError : configError ?? saleError;
   const tenderSession = useRef3(null);
+  const droppedReference = useRef3(null);
   const confirmed = useRef3(null);
   const [canContinue, setCanContinue] = useState3(false);
   const attempts = useRef3(0);
@@ -2921,13 +3538,36 @@ function useSale(settings, opts) {
     if (active) setError(SALE_SAVING);
     return active;
   }
+  function resetSale(customer) {
+    if (inFlight.current && !pending.current) return setError(SALE_SAVING);
+    if (pending.current && confirmed.current !== pending.current) {
+      if (inFlight.current) checkStored(pending.current);
+      return setError(SALE_SAVING);
+    }
+    confirm(null);
+    pending.current = null;
+    inFlight.current = null;
+    tenderSession.current = null;
+    droppedReference.current = null;
+    setSaving(false);
+    madeWith.current = { taxContext, currency: settings.currency };
+    const next = createOrderBuilder({ currency: settings.currency, taxContext });
+    if (customer !== null) next.setCustomer(customer);
+    builderNow.current = next;
+    setBuilder(next);
+    setOrder(next.getSnapshot());
+    setStage({ kind: "cart" });
+    setError(null);
+  }
   useEffect3(() => {
-    const subscription = builder.order$.subscribe(setOrder);
+    const subscription = rendered.order$.subscribe(setOrder);
     return () => subscription.unsubscribe();
-  }, [builder]);
+  }, [rendered]);
   const idle2 = stage.kind === "cart" && !order.lineItems.length;
-  useEffect3(() => {
-    if (idle2 && (madeWith.current.taxContext !== taxContext || madeWith.current.currency !== settings.currency)) result.newSale();
+  useLayoutEffect(() => {
+    const live = builderNow.current.getSnapshot();
+    const liveIdle = stageNow.current.kind === "cart" && !live.lineItems.length && !inFlight.current && !pending.current;
+    if (liveIdle && (madeWith.current.taxContext !== taxContext || madeWith.current.currency !== settings.currency)) resetSale(live.customer ?? null);
   });
   useEffect3(() => () => {
     clearHungSaveTimer();
@@ -2940,10 +3580,19 @@ function useSale(settings, opts) {
   }, []);
   function setTender(tender) {
     if (locked()) return;
+    const reason = referenceReason(tender?.reference);
+    const dropped = reason && (reason === "nul" ? "it contains a NUL character" : `it is over ${PAYLOAD_STRING_MAX} characters`);
+    const kept = tender && dropped ? { method: tender.method, amountMinor: tender.amountMinor } : tender;
+    const builder = builderNow.current;
     const previous = builder.getSnapshot().payments[0];
     if (previous) builder.removePayment(previous.id);
-    if (tender) builder.addPayment(tender);
-    setError(null);
+    const paymentId = kept ? builder.addPayment(kept) : null;
+    droppedReference.current = dropped ? paymentId : null;
+    setError(dropped && `The terminal's payment reference couldn't be kept (${dropped}); the payment is recorded without it.`);
+    try {
+      if (dropped) saleLogger.warn("the terminal's payment reference was dropped", { reason: dropped, method: tender.method });
+    } catch {
+    }
   }
   function checkStored(completion) {
     const attempt2 = attempts.current;
@@ -2981,10 +3630,11 @@ function useSale(settings, opts) {
     if (hungSaveTimer.current === timer) clearHungSaveTimer();
     if (pending.current !== completion) return;
     pending.current = null;
+    droppedReference.current = null;
     confirm(null);
     setSaving(false);
     setError(null);
-    stageNow.current = { kind: "receipt", order: completion.order, posOrder: completion.posOrder };
+    stageNow.current = { kind: "receipt", order: withSentForm(completion.order, completion.posOrder), posOrder: completion.posOrder };
     setStage(stageNow.current);
   }
   function once(attempt2) {
@@ -3007,8 +3657,21 @@ function useSale(settings, opts) {
     canContinue,
     add(entry, traits) {
       if (locked()) return;
+      const builder = builderNow.current;
       try {
-        addEntryToCart(builder, entry, traits, madeWith.current.currency);
+        const known = new Set(builder.getSnapshot().lineItems.map((line2) => line2.id));
+        const lineId = addEntryToCart(builder, entry, traits, madeWith.current.currency);
+        const line = builder.getSnapshot().lineItems.find((item) => item.id === lineId && !known.has(item.id));
+        const name = line && `"${cutText(line.name, MESSAGE_NAME_MAX)}"`;
+        const taxLines = line && (opts.capabilities?.orderCreate ?? 1) >= 3 ? line.taxLines : [];
+        const refused = line && [
+          line.variantId !== void 0 ? referenceError(`${name}: the variant id`, line.variantId) : referenceError(`${name}: the product id`, line.productId),
+          ...taxLines.map((tax) => referenceError(`${name}: the tax code`, tax.code))
+        ].find((message) => message !== null);
+        if (refused) {
+          builder.removeItem(lineId);
+          return setError(refused);
+        }
         setError(null);
       } catch (error2) {
         if (!(error2 instanceof CartError)) throw error2;
@@ -3016,15 +3679,16 @@ function useSale(settings, opts) {
       }
     },
     setQuantity(lineId, quantity) {
-      if (!locked()) builder.updateQuantity(lineId, quantity);
+      if (!locked()) builderNow.current.updateQuantity(lineId, quantity);
     },
     remove(lineId) {
-      if (!locked()) builder.removeItem(lineId);
+      if (!locked()) builderNow.current.removeItem(lineId);
     },
     /** A line's discount, or the order's without a line; returns the refusal to show, or null once applied. */
     applyDiscount(lineId, discount) {
       if (locked()) return SALE_SAVING;
       if ((opts.capabilities?.orderCreate ?? 1) < 2) return DISCOUNTS_UNSUPPORTED;
+      const builder = builderNow.current;
       const applied = (snapshot) => lineId === null ? snapshot.discounts : snapshot.lineItems.find((line) => line.id === lineId)?.discounts ?? [];
       const before = new Set(applied(builder.getSnapshot()).map((entry) => entry.id));
       if (lineId === null) builder.applyOrderDiscount(discount);
@@ -3037,7 +3701,15 @@ function useSale(settings, opts) {
       return null;
     },
     removeDiscount(id2) {
-      if (!locked()) builder.removeDiscount(id2);
+      if (!locked()) builderNow.current.removeDiscount(id2);
+    },
+    /** the picked customer reaches the server as order.create v3's customer.customerId */
+    setCustomer(customer) {
+      if (locked()) return;
+      const refused = customer && customerRefusal(customer);
+      if (refused) return setError(refused);
+      builderNow.current.setCustomer(customer);
+      setError((current) => current !== null && CUSTOMER_REFUSALS.includes(current) ? null : current);
     },
     /**
      * Pins `options.session` for this tender when given, else the rendered `session` option. Pass the
@@ -3046,7 +3718,7 @@ function useSale(settings, opts) {
      */
     startTender(method, options) {
       if (locked()) return;
-      const current = builder.getSnapshot();
+      const current = builderNow.current.getSnapshot();
       if (!current.lineItems.length) return;
       tenderSession.current ??= { session: options?.session ?? opts.session };
       setTender(method === "external" ? { method, amountMinor: current.totalMinor } : null);
@@ -3070,17 +3742,24 @@ function useSale(settings, opts) {
      * and `createdAt`, no new stamp and no second late-sale fact) and hands it to `onSaleCompleted`
      * again, so that must accept an order it already stored (as `useOrderOutbox.record` does). The
      * pending completion is cleared once `onSaleCompleted` resolves, or by `newSale()`. A call while
-     * another is in flight returns that call's promise, and a call on the receipt does nothing.
+     * another is in flight returns that call's promise, and a call on the receipt does nothing. While
+     * `cashierRef` or `registerId` is out of bounds (shown as `error`), a call does nothing either,
+     * unless it's the Retry of a pending completion, which was built with the options as they were.
      */
-    complete: () => once(async () => {
+    complete: () => configError && !pending.current && !inFlight.current ? Promise.resolve() : once(async () => {
       attempts.current++;
       confirm(null);
       if (pending.current) return deliver(pending.current);
       setSaving(true);
-      const current = builder.getSnapshot();
+      const current = builderNow.current.getSnapshot();
       let posOrder;
       try {
-        posOrder = finalizeOrder(current, { registerId: opts.registerId, cashierRef: opts.cashierRef, capabilities: opts.capabilities });
+        posOrder = finalizeOrder(current, {
+          registerId: opts.registerId,
+          cashierRef: opts.cashierRef,
+          capabilities: opts.capabilities,
+          ...droppedReference.current ? { localWarnings: [{ code: "payment_reference_dropped", paymentId: droppedReference.current }] } : {}
+        });
       } catch (error2) {
         setSaving(false);
         setError(error2.message);
@@ -3131,22 +3810,7 @@ function useSale(settings, opts) {
      * updates or requeues `pos_orders` itself.
      */
     newSale() {
-      if (inFlight.current && !pending.current) return setError(SALE_SAVING);
-      if (pending.current && confirmed.current !== pending.current) {
-        if (inFlight.current) checkStored(pending.current);
-        return setError(SALE_SAVING);
-      }
-      confirm(null);
-      pending.current = null;
-      inFlight.current = null;
-      tenderSession.current = null;
-      setSaving(false);
-      madeWith.current = { taxContext, currency: settings.currency };
-      const next = createOrderBuilder({ currency: settings.currency, taxContext });
-      setBuilder(next);
-      setOrder(next.getSnapshot());
-      setStage({ kind: "cart" });
-      setError(null);
+      resetSale(null);
     },
     /**
      * Continue after a failed save whose order is confirmed stored (`canContinue`): exactly `newSale()`.
@@ -3222,11 +3886,11 @@ function createHttpCommandTransport(options) {
         try {
           body = await response.json();
         } catch {
-          return retry(controller.signal.aborted ? "network" : "bad_body");
+          return retry(controller.signal.aborted ? "timeout" : "bad_body");
         }
         return isCommandBatchResponse(body) ? { kind: "results", results: body.results } : retry("bad_body");
       } catch {
-        return { kind: "retry", reason: "network" };
+        return { kind: "retry", reason: controller.signal.aborted ? "timeout" : "network" };
       } finally {
         clearTimeout(timeout);
       }
@@ -3235,9 +3899,36 @@ function createHttpCommandTransport(options) {
 }
 
 // src/outbox/order-outbox.ts
+import { deepEqual as deepEqual2 } from "rxdb";
+import { BehaviorSubject as BehaviorSubject4 } from "rxjs";
+
+// src/outbox/backend-not-found.ts
 import { BehaviorSubject as BehaviorSubject3 } from "rxjs";
+var NOT_FOUND_BEFORE_NOTICE = 3;
+function createBackendNotFound() {
+  let count = 0;
+  let since = 0;
+  const backendMissing$ = new BehaviorSubject3(void 0);
+  return {
+    backendMissing$,
+    record(outcome, at2) {
+      if (outcome.kind === "retry" && outcome.reason === "network") return;
+      if (outcome.kind === "retry" && outcome.reason === "status_404") {
+        if (count++ === 0) since = at2;
+      } else count = 0;
+      const missing = count >= NOT_FOUND_BEFORE_NOTICE;
+      if (missing !== !!backendMissing$.value) backendMissing$.next(missing ? { since } : void 0);
+    }
+  };
+}
+
+// src/outbox/order-outbox.ts
 var AUTH_FAILURES_BEFORE_PROMPT = 3;
 var NOT_REQUEUEABLE = /* @__PURE__ */ new Set(["idempotency_mismatch"]);
+var REFUSAL_LOG_MESSAGE_MAX = 200;
+var ISOLATE_AFTER_ATTEMPTS = 5;
+var STUCK_AFTER_MS = 15 * 6e4;
+var validMax = (max) => typeof max === "number" && Number.isSafeInteger(max) && max > 0 ? max : void 0;
 function createOrderOutbox(options) {
   const { collection, transport, deviceId } = options;
   const batchSize = Math.min(options.batchSize ?? 10, 10);
@@ -3245,7 +3936,13 @@ function createOrderOutbox(options) {
   const maxBackoff = options.maxBackoffMs ?? 6e4;
   const random = options.random ?? Math.random;
   const now = options.now ?? Date.now;
-  const state$ = new BehaviorSubject3({ pending: 0, sending: false });
+  const state$ = new BehaviorSubject4({ pending: 0, sending: false });
+  const backendNotFound = options.backendNotFound ?? createBackendNotFound();
+  let missingSubscription;
+  const watchBackendMissing = () => missingSubscription ??= backendNotFound.backendMissing$.subscribe((backendMissing) => {
+    if (backendMissing !== state$.value.backendMissing) state$.next({ ...state$.value, backendMissing });
+  });
+  watchBackendMissing();
   const attempts = /* @__PURE__ */ new Map();
   let backoff = initialBackoff;
   let unauthorizedSinceAccepted = 0;
@@ -3255,20 +3952,103 @@ function createOrderOutbox(options) {
   let stopped = false;
   let insertedDuringRun = false;
   let stoppedDuringRun = false;
+  const isolateAfter = options.isolateAfterAttempts ?? ISOLATE_AFTER_ATTEMPTS;
+  const stuckAfter = options.stuckAfterMs ?? STUCK_AFTER_MS;
+  let head;
+  let walk;
+  const isolated = /* @__PURE__ */ new Map();
+  const clocks = /* @__PURE__ */ new Map();
+  let failureSeq = 0;
+  let turn = "batch";
+  let isolatedWait = false;
+  let runProgressed = false;
+  let timerFiredDuringRun = false;
+  let restored = false;
+  function stuckState() {
+    const stuck = [...clocks].filter(([, clock]) => (clock.pausedAt ?? now()) - clock.since >= stuckAfter);
+    if (!stuck.length) return void 0;
+    return {
+      commandIds: stuck.map(([id2]) => id2),
+      since: Math.min(...stuck.map(([, clock]) => clock.since)),
+      reason: stuck.reduce((latest, entry) => entry[1].seq > latest[1].seq ? entry : latest)[1].reason,
+      orders: stuck.map(([commandId, { since, reason }]) => ({ commandId, since, reason }))
+    };
+  }
+  function isDue(id2) {
+    const entry = isolated.get(id2);
+    return !!entry && (entry.nextAt <= now() || entry.nextAt - now() > maxBackoff);
+  }
+  function failuresOf(commandId) {
+    const clock = clocks.get(commandId);
+    return clock && {
+      since: clock.since,
+      reason: clock.reason.slice(0, 64),
+      isolated: isolated.has(commandId) || !!walk?.failed.has(commandId)
+    };
+  }
+  async function mirror() {
+    if (!clocks.size) return;
+    for (const order of await readFresh(collection, { selector: { syncStatus: "pending", commandId: { $in: [...clocks.keys()] } } })) {
+      const value = failuresOf(order.commandId);
+      if (!value || deepEqual2(value, order.serverFailures)) continue;
+      await (await collection.findOne(order.id).exec())?.incrementalModify((data) => {
+        if (data.syncStatus === "pending" && data.commandId === order.commandId) data.serverFailures = value;
+        return data;
+      });
+    }
+  }
+  async function restore() {
+    for (const { commandId, serverFailures } of await readFresh(collection, { selector: {
+      syncStatus: "pending",
+      serverFailures: { $exists: true }
+    }, sort: [{ createdAt: "asc" }] })) if (serverFailures) {
+      const { since, reason } = serverFailures;
+      clocks.set(commandId, { since, pausedAt: now(), seq: ++failureSeq, reason });
+      if (serverFailures.isolated) isolated.set(commandId, { backoff: initialBackoff, nextAt: now(), reason });
+    }
+    restored = true;
+  }
+  const bare = ({ serverFailures, _rev, _meta, ...data }) => data;
+  const failuresOnly = (before, after) => !deepEqual2(before.serverFailures, after.serverFailures) && deepEqual2(bare(before), bare(after));
+  const recordsSentForm = (before, after) => deepEqual2(bare({ ...freezeSentForm(before), sentVersion: before.sentVersion ?? after.sentVersion }), bare(after));
   async function updateState(patch = {}) {
     const pending = await countFresh(collection, { syncStatus: "pending" });
-    state$.next({ ...state$.value, ...patch, pending });
+    const rejected = await countFresh(collection, { syncStatus: "rejected" });
+    state$.next({ ...state$.value, ...patch, pending, rejected, stuck: stuckState() });
   }
-  function scheduleRetry(reason, retryAfterMs = 0) {
+  function isolate(id2, reason, retryAfterMs = 0) {
+    const entry = isolated.get(id2) ?? { backoff: initialBackoff };
+    const delay = Math.min(Math.max(retryAfterMs, entry.backoff * (0.9 + 0.2 * random())), maxBackoff);
+    isolated.set(id2, { reason, backoff: Math.min(entry.backoff * 2, maxBackoff), nextAt: now() + delay });
+  }
+  function serverFailed(orders, alone, reason, retryAfterMs) {
+    const at2 = now();
+    for (const { commandId } of orders) clocks.set(commandId, { since: clocks.get(commandId)?.since ?? at2, seq: ++failureSeq, reason });
+    const id2 = orders[0].commandId;
+    if (alone === "isolated") {
+      isolate(id2, reason, retryAfterMs);
+      if (runProgressed && retryAfterMs === void 0 && reason !== "status_429") return void 0;
+      return Math.max(retryAfterMs ?? 0, isolated.get(id2).nextAt - now());
+    }
+    if (alone === "probe") walk?.failed.set(id2, reason);
+    else {
+      head = { id: id2, count: head?.id === id2 ? head.count + 1 : 1 };
+      if (head.count >= isolateAfter) walk ??= { failed: /* @__PURE__ */ new Map() };
+    }
+    return retryAfterMs ?? 0;
+  }
+  function scheduleRetry(reason, retryAfterMs = 0, wait) {
     state$.next({ ...state$.value, lastRetryReason: reason });
     if (stopped) {
       stoppedDuringRun = true;
       return;
     }
-    const delay = Math.min(Math.max(retryAfterMs, backoff * (0.9 + 0.2 * random())), maxBackoff);
-    backoff = Math.min(backoff * 2, maxBackoff);
+    const delay = wait ?? Math.min(Math.max(retryAfterMs, backoff * (0.9 + 0.2 * random())), maxBackoff);
+    if (wait === void 0) backoff = Math.min(backoff * 2, maxBackoff);
+    isolatedWait = wait !== void 0;
     timer = setTimeout(() => {
       timer = void 0;
+      if (running) timerFiredDuringRun = true;
       flush().catch(() => {
       });
     }, delay);
@@ -3276,26 +4056,89 @@ function createOrderOutbox(options) {
   }
   async function run() {
     stoppedDuringRun = false;
+    runProgressed = false;
+    const sentAlone = /* @__PURE__ */ new Set();
     while (!stopped) try {
+      if (!restored) await restore();
       await updateState({ sending: true, nextAttemptAt: void 0 });
       insertedDuringRun = false;
-      const orders = await readFresh(collection, {
-        selector: { syncStatus: "pending" },
+      const tracked = [.../* @__PURE__ */ new Set([...isolated.keys(), ...clocks.keys()])];
+      const held = tracked.length ? await readFresh(collection, {
+        selector: { syncStatus: "pending", commandId: { $in: tracked } },
+        sort: [{ createdAt: "asc" }]
+      }) : [];
+      for (const id2 of tracked) if (!held.some((order) => order.commandId === id2)) {
+        isolated.delete(id2);
+        clocks.delete(id2);
+      }
+      let probe;
+      if (walk) {
+        [probe] = await readFresh(collection, { selector: {
+          syncStatus: "pending",
+          commandId: { $nin: [...isolated.keys(), ...walk.failed.keys()] }
+        }, sort: [{ createdAt: "asc" }], limit: 1 });
+        if (!probe) {
+          walk = void 0;
+          head = void 0;
+        }
+      }
+      const [due] = held.filter((order) => isDue(order.commandId) && !sentAlone.has(order.commandId)).sort((a, b) => isolated.get(a.commandId).nextAt - isolated.get(b.commandId).nextAt);
+      let orders = turn === "isolated" && due ? [due] : probe ? [probe] : await readFresh(collection, {
+        selector: { syncStatus: "pending", ...isolated.size ? { commandId: { $nin: [...isolated.keys()] } } : {} },
         sort: [{ createdAt: "asc" }],
         limit: batchSize
       });
+      if (!orders.length && due) orders = [due];
       if (!orders.length || stopped) {
-        stoppedDuringRun = stopped;
-        return;
+        if (stopped || !isolated.size) {
+          stoppedDuringRun = stopped;
+          return;
+        }
+        if (insertedDuringRun) continue;
+        const next = [...isolated.values()].sort((a, b) => a.nextAt - b.nextAt)[0];
+        return scheduleRetry(next.reason, 0, Math.min(maxBackoff, Math.max(initialBackoff, next.nextAt - now())));
       }
-      const batch = orders.map((order) => {
+      const alone = due && orders[0] === due ? "isolated" : probe ? "probe" : void 0;
+      if (alone === "isolated") sentAlone.add(orders[0].commandId);
+      turn = alone === "isolated" ? "batch" : "isolated";
+      const firstSend = orders.some((order) => order.sentVersion === void 0);
+      const serverMax = firstSend && validMax(await Promise.resolve().then(() => options.getMaxOrderCreateVersion?.()).catch((cause) => {
+        outboxLogger.warn("Failed to read capabilities", { cause });
+      })) || 3;
+      const batch = await Promise.all(orders.map(async (order) => {
+        const frozen = freezeSentForm(order);
         const attempt2 = (attempts.get(order.commandId) ?? 0) + 1;
         attempts.set(order.commandId, attempt2);
-        return toOrderCreateEnvelope(order, deviceId, attempt2);
-      });
-      const outcome = await transport.send(batch);
+        let envelope2;
+        try {
+          envelope2 = toOrderCreateEnvelope(frozen, deviceId, attempt2, { maxVersion: order.sentVersion ?? serverMax });
+        } catch (cause) {
+          if (!(cause instanceof UnsupportedOrderVersionError)) throw cause;
+          envelope2 = toOrderCreateEnvelope(frozen, deviceId, attempt2, { maxVersion: 3 });
+        }
+        if (frozen !== order || order.sentVersion === void 0) {
+          await (await collection.findOne(order.id).exec())?.incrementalModify((data) => ({ ...freezeSentForm(data), sentVersion: data.sentVersion ?? envelope2.version }));
+        }
+        return envelope2;
+      }));
+      let outcome = await transport.send(batch);
+      backendNotFound.record(outcome, now());
+      if (outcome.kind !== "retry" || outcome.reason !== "network") {
+        const at2 = now();
+        for (const clock of clocks.values()) if (clock.pausedAt !== void 0) {
+          clock.since += at2 - clock.pausedAt;
+          clock.pausedAt = void 0;
+        }
+      }
+      let batchMax;
+      let capabilitiesRefreshed = false;
       if (outcome.kind === "retry") {
-        return scheduleRetry(outcome.reason, outcome.retryAfterMs);
+        let floor = outcome.retryAfterMs;
+        if (outcome.reason === "network") {
+          for (const clock of clocks.values()) clock.pausedAt ??= now();
+          walk = void 0;
+        } else if ((floor = serverFailed(orders, alone, outcome.reason, outcome.retryAfterMs)) === void 0) continue;
+        return scheduleRetry(outcome.reason, floor);
       }
       if (outcome.kind === "unauthorized") {
         unauthorizedSinceAccepted++;
@@ -3309,6 +4152,28 @@ function createOrderOutbox(options) {
         });
         return;
       }
+      if (outcome.kind === "refused" && outcome.status === 400 && options.getMaxOrderCreateVersion) {
+        const match = /^Invalid commands\[(\d+)\]\.version$/.exec(outcome.reason);
+        if (match) {
+          try {
+            await options.refreshCapabilities?.();
+          } catch (cause) {
+            outboxLogger.warn("Failed to refresh capabilities", { cause });
+          }
+          const advertised = await options.getMaxOrderCreateVersion();
+          const max = typeof advertised === "number" && Number.isSafeInteger(advertised) && advertised > 0 ? advertised : void 0;
+          if (max !== void 0 && max < batch[Number(match[1])]?.version) {
+            batchMax = max;
+            capabilitiesRefreshed = true;
+            const message = outcome.reason;
+            outcome = { kind: "results", results: batch.filter((command) => command.version > max).map((command) => ({
+              id: command.id,
+              status: "rejected",
+              error: { code: "unsupported_version", message, data: { orderCreate: max } }
+            })) };
+          }
+        }
+      }
       if (outcome.kind === "refused") {
         unauthorizedSinceAccepted = 0;
         state$.next({
@@ -3324,6 +4189,7 @@ function createOrderOutbox(options) {
       unauthorizedSinceAccepted = 0;
       state$.next({ ...state$.value, authRequired: false, refused: void 0 });
       let progressed = false;
+      let downgraded = false;
       for (const order of orders) {
         const result = outcome.results.find((entry) => entry.id === order.commandId);
         if (!result) continue;
@@ -3331,20 +4197,79 @@ function createOrderOutbox(options) {
         if (stored?.syncStatus !== "pending" || stored.commandId !== order.commandId) continue;
         const current = await collection.findOne(order.id).exec();
         if (!current) continue;
+        let error = result.error;
+        if (result.status === "rejected" && error?.code === "unsupported_version" && options.getMaxOrderCreateVersion) {
+          if (!capabilitiesRefreshed) {
+            try {
+              await options.refreshCapabilities?.();
+            } catch (cause) {
+              outboxLogger.warn("Failed to refresh capabilities", { cause });
+            }
+            const advertised = error.data?.orderCreate;
+            const max2 = typeof advertised === "number" && Number.isSafeInteger(advertised) && advertised > 0 ? advertised : await options.getMaxOrderCreateVersion();
+            batchMax = typeof max2 === "number" && Number.isSafeInteger(max2) && max2 > 0 ? max2 : void 0;
+            capabilitiesRefreshed = true;
+          }
+          const max = batchMax;
+          const from = batch.find((command) => command.id === order.commandId).version;
+          if (max !== void 0 && max < (stored.sentVersion ?? from)) {
+            try {
+              const to = toOrderCreateEnvelope(stored, deviceId, 1, { maxVersion: max }).version;
+              let changed = false;
+              await current.incrementalModify((data) => {
+                changed = data.syncStatus === "pending" && data.commandId === order.commandId && max < (data.sentVersion ?? from);
+                if (changed) {
+                  data.sentVersion = to;
+                  data.downgradedFrom ??= from;
+                  delete data.serverFailures;
+                }
+                return data;
+              });
+              if (changed) {
+                outboxLogger.warn("Sent an order at a lower order.create version", { orderId: order.id, from, to });
+                progressed = downgraded = true;
+                clocks.delete(order.commandId);
+              }
+              continue;
+            } catch (cause) {
+              if (!(cause instanceof UnsupportedOrderVersionError)) throw cause;
+              error = { code: "unsupported_version", message: cause.message };
+            }
+          }
+        }
+        if (result.status === "rejected") outboxLogger[error?.code === "unsupported_version" ? "error" : "warn"](
+          "Order refused by the store",
+          { orderId: order.id, code: error?.code, message: error?.message?.slice(0, REFUSAL_LOG_MESSAGE_MAX) }
+        );
         const updatedAt = new Date(now()).toISOString();
-        await current.incrementalPatch(result.status === "rejected" ? { syncStatus: "rejected", error: result.error, updatedAt } : {
-          syncStatus: "applied",
-          serverRefs: result.serverRefs,
-          ...result.warnings ? { warnings: result.warnings } : {},
-          updatedAt
+        await current.incrementalModify((data) => {
+          delete data.serverFailures;
+          return Object.assign(data, result.status === "rejected" ? { syncStatus: "rejected", error, updatedAt } : {
+            syncStatus: "applied",
+            serverRefs: result.serverRefs,
+            ...result.warnings ? { warnings: result.warnings } : {},
+            updatedAt
+          });
         });
         attempts.delete(order.commandId);
+        isolated.delete(order.commandId);
+        clocks.delete(order.commandId);
         progressed = true;
         await updateState();
       }
-      if (!progressed) return scheduleRetry("no_progress");
+      if (!progressed) {
+        const floor = serverFailed(orders, alone, "no_progress");
+        if (floor === void 0) continue;
+        return scheduleRetry("no_progress", floor);
+      }
+      runProgressed = true;
+      if (alone !== "isolated") head = void 0;
+      if (walk && alone === "probe") {
+        for (const [id2, reason] of walk.failed) isolate(id2, reason);
+        walk = void 0;
+      }
       backoff = initialBackoff;
-      state$.next({ ...state$.value, lastRetryReason: void 0 });
+      state$.next({ ...state$.value, lastRetryReason: downgraded ? "downgraded" : void 0 });
     } catch (error) {
       scheduleRetry("error: " + (error instanceof Error ? error.message : String(error)));
       return;
@@ -3354,16 +4279,26 @@ function createOrderOutbox(options) {
   function flush() {
     if (running) return running;
     stopped = false;
+    watchBackendMissing();
     clearTimeout(timer);
     timer = void 0;
     running = Promise.resolve().then(run).finally(async () => {
+      try {
+        await mirror();
+      } catch (cause) {
+        outboxLogger.warn("Failed to store server failures", { cause });
+      }
       try {
         await updateState({ sending: false });
       } catch {
       }
       running = void 0;
-      if ((insertedDuringRun || stoppedDuringRun) && !stopped && timer === void 0) flush().catch(() => {
-      });
+      const missed = timerFiredDuringRun;
+      timerFiredDuringRun = false;
+      if (!stopped && (missed || (insertedDuringRun || stoppedDuringRun) && (timer === void 0 || insertedDuringRun && isolatedWait))) {
+        flush().catch(() => {
+        });
+      }
     });
     return running;
   }
@@ -3386,6 +4321,9 @@ function createOrderOutbox(options) {
           if (!changed) return data;
           data.syncStatus = "pending";
           delete data.error;
+          delete data.serverFailures;
+          delete data.sentVersion;
+          delete data.downgradedFrom;
           data.commandId = uuidv7();
           data.updatedAt = new Date(now()).toISOString();
           return data;
@@ -3402,6 +4340,275 @@ function createOrderOutbox(options) {
     },
     start() {
       stopped = false;
+      watchBackendMissing();
+      if (!subscription) subscription = collection.$.subscribe((event) => {
+        if (event.documentData?.syncStatus === "pending" && (event.operation === "INSERT" || event.operation === "UPDATE" && !(event.previousDocumentData !== void 0 && (failuresOnly(event.previousDocumentData, event.documentData) || recordsSentForm(event.previousDocumentData, event.documentData))))) {
+          insertedDuringRun = true;
+          flush().catch(() => {
+          });
+        }
+      });
+      if (!stopped) flush().catch(() => {
+      });
+    },
+    stop() {
+      stopped = true;
+      clearTimeout(timer);
+      timer = void 0;
+      subscription?.unsubscribe();
+      subscription = void 0;
+      missingSubscription?.unsubscribe();
+      missingSubscription = void 0;
+      state$.next({ ...state$.value, nextAttemptAt: void 0 });
+    }
+  };
+}
+
+// src/outbox/register-outbox.ts
+import { BehaviorSubject as BehaviorSubject5 } from "rxjs";
+function plainCommand({
+  key,
+  registerId,
+  seq,
+  commandId,
+  type,
+  version,
+  payload,
+  createdAt,
+  syncStatus,
+  error,
+  result,
+  updatedAt
+}) {
+  return structuredClone({
+    key,
+    registerId,
+    seq,
+    commandId,
+    type,
+    version,
+    payload,
+    createdAt,
+    syncStatus,
+    ...error ? { error } : {},
+    ...result ? { result } : {},
+    updatedAt
+  });
+}
+function createRegisterOutbox(options) {
+  const { collection, transport, deviceId } = options;
+  const size = options.batchSize;
+  const batchSize = Math.max(1, Math.min(typeof size === "number" && Number.isFinite(size) ? Math.floor(size) : 10, 10));
+  const initialBackoff = options.initialBackoffMs ?? 1e3;
+  const maxBackoff = options.maxBackoffMs ?? 6e4;
+  const random = options.random ?? Math.random;
+  const now = options.now ?? Date.now;
+  const state$ = new BehaviorSubject5({ pending: 0, sending: false });
+  const backendNotFound = options.backendNotFound ?? createBackendNotFound();
+  let missingSubscription;
+  const watchBackendMissing = () => missingSubscription ??= backendNotFound.backendMissing$.subscribe((backendMissing) => {
+    if (backendMissing !== state$.value.backendMissing) state$.next({ ...state$.value, backendMissing });
+  });
+  watchBackendMissing();
+  const attempts = /* @__PURE__ */ new Map();
+  let backoff = initialBackoff;
+  let unauthorizedSinceAccepted = 0;
+  let running;
+  let timer;
+  let subscription;
+  let stopped = false;
+  let insertedDuringRun = false;
+  let stoppedDuringRun = false;
+  const stuckAfter = options.stuckAfterMs ?? STUCK_AFTER_MS;
+  const clocks = /* @__PURE__ */ new Map();
+  let failureSeq = 0;
+  function stuckState() {
+    const stuck = [...clocks].filter(([, clock]) => (clock.pausedAt ?? now()) - clock.since >= stuckAfter);
+    if (!stuck.length) return void 0;
+    return {
+      commandIds: stuck.map(([id2]) => id2),
+      since: Math.min(...stuck.map(([, clock]) => clock.since)),
+      reason: stuck.reduce((latest, entry) => entry[1].seq > latest[1].seq ? entry : latest)[1].reason,
+      orders: stuck.map(([commandId, { since, reason }]) => ({ commandId, since, reason }))
+    };
+  }
+  function serverFailed(commands, reason) {
+    const at2 = now();
+    for (const { commandId } of commands) clocks.set(commandId, { since: clocks.get(commandId)?.since ?? at2, seq: ++failureSeq, reason });
+  }
+  async function updateState(patch = {}) {
+    const pending = await countFresh(collection, { syncStatus: "pending" });
+    const sendable2 = /* @__PURE__ */ new Set();
+    const blocked = /* @__PURE__ */ new Set();
+    if (clocks.size) for (const command of await readFresh(collection, {
+      selector: { syncStatus: { $in: ["pending", "rejected"] } },
+      sort: [{ seq: "asc" }, { key: "asc" }]
+    })) {
+      if (command.syncStatus === "rejected") blocked.add(command.registerId);
+      else if (!blocked.has(command.registerId)) sendable2.add(command.commandId);
+    }
+    for (const id2 of clocks.keys()) if (!sendable2.has(id2)) clocks.delete(id2);
+    state$.next({ ...state$.value, ...patch, pending, stuck: stuckState() });
+  }
+  function scheduleRetry(reason, retryAfterMs = 0) {
+    state$.next({ ...state$.value, lastRetryReason: reason, stuck: stuckState() });
+    if (stopped) {
+      stoppedDuringRun = true;
+      return;
+    }
+    const delay = Math.min(Math.max(retryAfterMs, backoff * (0.9 + 0.2 * random())), maxBackoff);
+    backoff = Math.min(backoff * 2, maxBackoff);
+    timer = setTimeout(() => {
+      timer = void 0;
+      flush().catch(() => {
+      });
+    }, delay);
+    state$.next({ ...state$.value, sending: false, nextAttemptAt: now() + delay });
+  }
+  async function run() {
+    stoppedDuringRun = false;
+    while (!stopped) try {
+      await updateState({ sending: true, nextAttemptAt: void 0 });
+      insertedDuringRun = false;
+      if (options.isEnabled?.() === false) return;
+      const pending = await readFresh(collection, { selector: { syncStatus: "pending" } });
+      const registerIds = [...new Set(pending.map((command) => command.registerId))].sort();
+      let sent = false;
+      for (const registerId of registerIds) {
+        const ledger = await readFresh(collection, {
+          selector: { registerId, syncStatus: { $in: ["pending", "rejected"] } },
+          sort: [{ seq: "asc" }, { key: "asc" }]
+        });
+        const commands = [];
+        for (const command of ledger) {
+          if (command.syncStatus === "rejected") break;
+          commands.push(command);
+          if (commands.length >= batchSize) break;
+        }
+        if (stopped) {
+          stoppedDuringRun = true;
+          return;
+        }
+        if (!commands.length) continue;
+        sent = true;
+        const batch = commands.map((doc) => {
+          const attempt2 = (attempts.get(doc.commandId) ?? 0) + 1;
+          attempts.set(doc.commandId, attempt2);
+          return {
+            id: doc.commandId,
+            type: doc.type,
+            version: doc.version,
+            payload: doc.payload,
+            createdAt: doc.createdAt,
+            deviceId,
+            attempt: attempt2
+          };
+        });
+        const outcome = await transport.send(batch);
+        backendNotFound.record(outcome, now());
+        const at2 = now();
+        if (outcome.kind === "retry" && outcome.reason === "network") for (const clock of clocks.values()) clock.pausedAt ??= at2;
+        else for (const clock of clocks.values()) if (clock.pausedAt !== void 0) {
+          clock.since += at2 - clock.pausedAt;
+          clock.pausedAt = void 0;
+        }
+        if (outcome.kind === "retry") {
+          if (outcome.reason !== "network") serverFailed(commands, outcome.reason);
+          return scheduleRetry(outcome.reason, outcome.retryAfterMs);
+        }
+        if (outcome.kind === "unauthorized") {
+          unauthorizedSinceAccepted++;
+          if (unauthorizedSinceAccepted < 3) return scheduleRetry("unauthorized");
+          state$.next({
+            ...state$.value,
+            authRequired: true,
+            lastRetryReason: "unauthorized",
+            sending: false,
+            nextAttemptAt: void 0
+          });
+          return;
+        }
+        if (outcome.kind === "refused") {
+          unauthorizedSinceAccepted = 0;
+          state$.next({
+            ...state$.value,
+            refused: { status: outcome.status, reason: outcome.reason },
+            authRequired: false,
+            lastRetryReason: "refused",
+            sending: false,
+            nextAttemptAt: void 0
+          });
+          return;
+        }
+        unauthorizedSinceAccepted = 0;
+        state$.next({ ...state$.value, authRequired: false, refused: void 0 });
+        let progressed = false;
+        for (const command of commands) {
+          const result = outcome.results.find((entry) => entry.id === command.commandId);
+          if (!result) continue;
+          const [stored] = await collection.storageInstance.findDocumentsById([command.key], false);
+          if (stored?.syncStatus !== "pending" || stored.commandId !== command.commandId) continue;
+          const current = await collection.findOne(command.key).exec();
+          if (!current) continue;
+          const error = result.error && {
+            code: result.error.code,
+            message: result.error.message,
+            ...result.error.data ? { data: result.error.data } : {}
+          };
+          const normalized = result.status === "duplicate" && error ? { id: result.id, status: "rejected", error } : { ...result, ...error ? { error } : {} };
+          try {
+            await options.onResult?.(plainCommand(stored), normalized);
+          } catch (cause) {
+            registerCommandsLogger.warn("Failed to apply register command result", { commandId: command.commandId, cause });
+          }
+          const updatedAt = new Date(now()).toISOString();
+          await current.incrementalModify((row) => {
+            if (row.syncStatus !== "pending" || row.commandId !== command.commandId) return row;
+            return Object.assign(row, normalized.status === "rejected" ? { syncStatus: "rejected", error: normalized.error, updatedAt } : { syncStatus: "applied", ...normalized.register ? { result: normalized.register } : {}, updatedAt });
+          });
+          attempts.delete(command.commandId);
+          progressed = true;
+          await updateState();
+        }
+        if (!progressed) {
+          serverFailed(commands, "no_progress");
+          return scheduleRetry("no_progress");
+        }
+        backoff = initialBackoff;
+        state$.next({ ...state$.value, lastRetryReason: void 0 });
+      }
+      if (!sent) return;
+    } catch (error) {
+      scheduleRetry("error: " + (error instanceof Error ? error.message : String(error)));
+      return;
+    }
+    stoppedDuringRun = true;
+  }
+  function flush() {
+    if (running) return running;
+    stopped = false;
+    watchBackendMissing();
+    clearTimeout(timer);
+    timer = void 0;
+    running = Promise.resolve().then(run).finally(async () => {
+      try {
+        await updateState({ sending: false });
+      } catch {
+      }
+      running = void 0;
+      if ((insertedDuringRun || stoppedDuringRun) && !stopped && timer === void 0) flush().catch(() => {
+      });
+    });
+    return running;
+  }
+  updateState().catch(() => {
+  });
+  return {
+    state$,
+    flush,
+    start() {
+      stopped = false;
+      watchBackendMissing();
       if (!subscription) subscription = collection.$.subscribe((event) => {
         if (event.documentData?.syncStatus === "pending" && (event.operation === "INSERT" || event.operation === "UPDATE")) {
           insertedDuringRun = true;
@@ -3418,15 +4625,17 @@ function createOrderOutbox(options) {
       timer = void 0;
       subscription?.unsubscribe();
       subscription = void 0;
+      missingSubscription?.unsubscribe();
+      missingSubscription = void 0;
       state$.next({ ...state$.value, nextAttemptAt: void 0 });
     }
   };
 }
 
 // src/outbox/use-order-outbox.ts
-import { useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+import { useEffect as useEffect4, useMemo as useMemo4, useRef as useRef4, useState as useState4 } from "react";
 var idle = { pending: 0, sending: false };
-var outboxLogger = createLogger("outbox");
+var noneStuck = [];
 function useOrderOutbox(options) {
   const { storeKey, deviceId } = options;
   const latest = useRef4(options);
@@ -3452,7 +4661,15 @@ function useOrderOutbox(options) {
         await store.close();
         return;
       }
-      const outbox = createOrderOutbox({ collection: store.orders, deviceId, transport: latest.current.transport(storeKey) });
+      const outbox = createOrderOutbox({
+        collection: store.orders,
+        deviceId,
+        transport: latest.current.transport(storeKey),
+        getMaxOrderCreateVersion: latest.current.getMaxOrderCreateVersion ? () => latest.current.getMaxOrderCreateVersion?.() : void 0,
+        refreshCapabilities: latest.current.refreshCapabilities ? async () => {
+          await latest.current.refreshCapabilities?.();
+        } : void 0
+      });
       current.current = { storeKey, orders: store.orders, outbox };
       const status = outbox.state$.subscribe(setState);
       const history = watchFresh(store.orders, { sort: [{ createdAt: "desc" }], limit: 50 }).subscribe(setRecent);
@@ -3479,6 +4696,8 @@ function useOrderOutbox(options) {
     return () => latest.current.onBusy?.(false);
   }, [state.sending]);
   const ready = current.current?.storeKey === storeKey && !!storeKey;
+  const stuckKey = ready ? state.stuck?.commandIds.join(",") ?? "" : "";
+  const stuckCommandIds = useMemo4(() => stuckKey ? stuckKey.split(",") : noneStuck, [stuckKey]);
   return {
     orders: ready ? orders : null,
     state: ready ? state : idle,
@@ -3492,6 +4711,7 @@ function useOrderOutbox(options) {
       return opened && opened.storeKey === storeKey ? opened.outbox.requeue(orderIds) : 0;
     },
     savesInFlight: savesInFlightCount,
+    stuckCommandIds,
     async record(posOrder) {
       savesInFlight.current++;
       setSavesInFlightCount(savesInFlight.current);
@@ -3734,13 +4954,18 @@ export {
   PosOrderOpenClosedError,
   RegisterApprovalRequiredError,
   RegisterCloseIncompleteError,
+  RegisterIdInvalidError,
+  RegisterMovementAmountError,
+  RegisterMovementReasonError,
   RegisterMovementStrandedError,
   RegisterSessionAlreadyOpenError,
   RegisterSessionClosedError,
   RegisterSessionRequiredError,
   RegisterTenderInProgressError,
   SALE_SAVING,
+  TAX_ROUNDING_MIXED_NOTE,
   TaxProvider,
+  UnsupportedOrderVersionError,
   activePlan,
   addEntryToCart,
   addPosOrderCollection,
@@ -3759,16 +4984,19 @@ export {
   clampClosureScope,
   closeNeedsApproval,
   closeSession,
+  closureCommand,
   closureSchema,
   computeOrderTax,
   consoleSink,
   countFresh,
   countVariance,
+  createBackendNotFound,
   createHttpCommandTransport,
   createLogger,
   createOrderBuilder,
   createOrderManager,
   createOrderOutbox,
+  createRegisterOutbox,
   createRepository,
   denominationTotal,
   denominations,
@@ -3790,6 +5018,7 @@ export {
   minorToDecimal,
   mintClosureNumber,
   mintUuid,
+  movementCommand,
   movementFieldError,
   needsAttention,
   nextSaleCounter,
@@ -3809,8 +5038,12 @@ export {
   readBoundRegister,
   readFresh,
   readRegister,
+  reconcileRegisterCommands,
   recordMovement,
   recordRegisterFact,
+  registerCommandCollection,
+  registerCommandSchema,
+  registerCommandsLogger,
   registerFactsLogger,
   registerSessionCollection,
   registerSessionSchema,
@@ -3821,11 +5054,15 @@ export {
   sameSale,
   searchProducts,
   selectClosureRows,
+  sessionOpenCommand,
+  sessionTransitionCommand,
   stampSession,
   startCounting,
   stockOverlay$,
   stockOverlayAsOf$,
+  taxFiguresForBasket,
   taxLinesByRate,
+  taxLogger,
   taxMicros,
   taxProviderProps,
   tenderReducer,