@tallyui/pos 0.1.0 → 2.0.0

package/dist/index.js

@@ -82,26 +82,9 @@ function callbackSink(options) {
   };
 }
 
-// src/currency/format-currency.ts
-var formatters = /* @__PURE__ */ new Map();
-function getFormatter(currencyCode, locale) {
-  const key = `${currencyCode}:${locale ?? "default"}`;
-  let formatter = formatters.get(key);
-  if (!formatter) {
-    formatter = new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: currencyCode
-    });
-    formatters.set(key, formatter);
-  }
-  return formatter;
-}
-function formatCurrency(amount, currencyCode, locale) {
-  return getFormatter(currencyCode, locale).format(amount);
-}
-
 // src/currency/currency-provider.tsx
 import { createContext, useContext, useMemo, useCallback } from "react";
+import { formatMoney } from "@tallyui/core";
 import { jsx } from "react/jsx-runtime";
 var CurrencyCtx = createContext(null);
 function CurrencyProvider({ currencyCode, locale, children }) {
@@ -114,55 +97,131 @@ function useCurrencyFormatter() {
     throw new Error("useCurrencyFormatter() must be used within a <CurrencyProvider>");
   }
   return useCallback(
-    (amount) => formatCurrency(amount, ctx.currencyCode, ctx.locale),
-    [ctx.currencyCode, ctx.locale]
+    (money) => formatMoney(money, ctx.locale) ?? `${money.amount} ${money.currency}`,
+    [ctx.locale]
   );
 }
+function useCurrencyCode() {
+  const ctx = useContext(CurrencyCtx);
+  if (!ctx) {
+    throw new Error("useCurrencyCode() must be used within a <CurrencyProvider>");
+  }
+  return ctx.currencyCode;
+}
 
-// src/tax/calculate.ts
-function round2(n) {
-  return Math.round(n * 100) / 100;
+// src/tax/exact.ts
+var MICROS_PER_MINOR = 1000000n;
+function ratePpmFromPercent(percent) {
+  const value = String(percent);
+  const match = /^(\d+)(?:\.(\d{1,4}))?$/.exec(value);
+  if (!match || match[0] !== value) {
+    throw new RangeError("Percent must be a plain decimal with at most four fractional digits");
+  }
+  const ratePpm = BigInt(match[1]) * 10000n + BigInt((match[2] ?? "").padEnd(4, "0"));
+  if (ratePpm > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError("Rate must be a safe integer");
+  }
+  return Number(ratePpm);
 }
-function addTax(priceExclTax, rate) {
-  return round2(priceExclTax * (1 + rate));
+function taxMicros(amountMinor, ratePpm, pricesIncludeTax) {
+  if (!Number.isSafeInteger(amountMinor) || !Number.isSafeInteger(ratePpm) || ratePpm < 0) {
+    throw new RangeError("Amount must be a safe integer and rate a non-negative safe integer");
+  }
+  const tax = BigInt(amountMinor) * BigInt(ratePpm);
+  if (!pricesIncludeTax) return tax;
+  const numerator = tax * MICROS_PER_MINOR;
+  const denominator = MICROS_PER_MINOR + BigInt(ratePpm);
+  const sign = numerator < 0n ? -1n : 1n;
+  return sign * ((sign * numerator + denominator / 2n) / denominator);
 }
-function extractTax(priceInclTax, rate) {
-  if (rate === 0) return 0;
-  return round2(priceInclTax - priceInclTax / (1 + rate));
+function roundMicrosToMinor(micros) {
+  const sign = micros < 0n ? -1n : 1n;
+  const minor2 = sign * ((sign * micros + MICROS_PER_MINOR / 2n) / MICROS_PER_MINOR);
+  if (minor2 < -BigInt(Number.MAX_SAFE_INTEGER) || minor2 > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError("Rounded amount must be a safe integer");
+  }
+  return Number(minor2);
 }
-function calculateTax(price, rate, pricesIncludeTax) {
-  if (pricesIncludeTax) {
-    const taxAmount2 = extractTax(price, rate);
-    return {
-      priceInclTax: round2(price),
-      priceExclTax: round2(price - taxAmount2),
-      taxAmount: taxAmount2
-    };
+function computeOrderTax(lines, pricesIncludeTax) {
+  let amountTotal = 0n;
+  let taxTotal = 0n;
+  const lineTaxMicros = [];
+  for (const line of lines) {
+    if (!Number.isSafeInteger(line.quantity) || line.quantity < 1) {
+      throw new RangeError("Quantity must be a safe integer >= 1");
+    }
+    let tax = taxMicros(line.unitPriceMinor, line.ratePpm, false) * BigInt(line.quantity);
+    const amount = BigInt(line.unitPriceMinor) * BigInt(line.quantity);
+    if (pricesIncludeTax) {
+      const numerator = tax * MICROS_PER_MINOR;
+      const denominator = MICROS_PER_MINOR + BigInt(line.ratePpm);
+      const sign = numerator < 0n ? -1n : 1n;
+      tax = sign * ((sign * numerator + denominator / 2n) / denominator);
+    }
+    amountTotal += amount;
+    taxTotal += tax;
+    lineTaxMicros.push(tax);
+  }
+  const taxMinor = taxTotal / MICROS_PER_MINOR + BigInt(roundMicrosToMinor(taxTotal % MICROS_PER_MINOR));
+  const subtotalMinor = pricesIncludeTax ? amountTotal - taxMinor : amountTotal;
+  const totalMinor = pricesIncludeTax ? amountTotal : amountTotal + taxMinor;
+  for (const value of [subtotalMinor, taxMinor, totalMinor]) {
+    if (value < -BigInt(Number.MAX_SAFE_INTEGER) || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError("Order totals must be safe integers");
+    }
   }
-  const taxAmount = round2(price * rate);
   return {
-    priceExclTax: round2(price),
-    priceInclTax: round2(price + taxAmount),
-    taxAmount
+    subtotalMinor: Number(subtotalMinor),
+    taxMinor: Number(taxMinor),
+    totalMinor: Number(totalMinor),
+    lineTaxMicros
   };
 }
+function taxLinesByRate(lines, orderTaxMinor, taxLabels) {
+  const byRate = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const lineTaxMicros = line.taxLines.reduce((sum, tax) => sum + BigInt(tax.taxMicros), 0n);
+    const base = line.taxInclusive ? line.netMinor - roundMicrosToMinor(lineTaxMicros) : line.netMinor;
+    for (const tax of line.taxLines) {
+      const key = JSON.stringify([tax.code ?? "", tax.ratePpm]);
+      const existing = byRate.get(key);
+      byRate.set(key, {
+        code: tax.code,
+        ratePpm: tax.ratePpm,
+        micros: (existing?.micros ?? 0n) + BigInt(tax.taxMicros),
+        netMinor: (existing?.netMinor ?? 0) + base
+      });
+    }
+  }
+  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) },
+      remainder: micros - floor * MICROS_PER_MINOR
+    };
+  });
+  const leftover = orderTaxMinor - groups.reduce((sum, group) => sum + group.line.amountMinor, 0);
+  const ranked = [...groups].sort((a, b) => a.remainder === b.remainder ? b.line.ratePpm - a.line.ratePpm : a.remainder > b.remainder ? -1 : 1);
+  for (const group of ranked.slice(0, leftover)) group.line.amountMinor += 1;
+  return groups.map((group) => group.line);
+}
 
 // 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 TaxCtx = createContext2(null);
-function TaxProvider({ rates, pricesIncludeTax, children }) {
+function TaxProvider({ ratesPpm, pricesIncludeTax, children }) {
   const value = useMemo2(
-    () => ({
-      getTaxRate(taxClass) {
-        if (taxClass && taxClass in rates) {
-          return rates[taxClass];
-        }
-        return rates.default ?? 0;
-      },
-      pricesIncludeTax
-    }),
-    [rates, pricesIncludeTax]
+    () => {
+      if (Object.values(ratesPpm).some((rate) => !Number.isSafeInteger(rate) || rate < 0)) {
+        throw new RangeError("TaxProvider: rates must be integer ppm");
+      }
+      return {
+        getTaxRatePpm: (taxClass) => (taxClass === void 0 ? void 0 : ratesPpm[taxClass]) ?? ratesPpm.default ?? 0,
+        pricesIncludeTax
+      };
+    },
+    [ratesPpm, pricesIncludeTax]
   );
   return /* @__PURE__ */ jsx2(TaxCtx.Provider, { value, children });
 }
@@ -174,12 +233,89 @@ function useTax() {
   return ctx;
 }
 
+// src/store-settings/resolve-store-settings.ts
+import { StoreSettingsError } from "@tallyui/core";
+function narrowInitial(tried, choices) {
+  const region = !choices.regions || choices.regions.some((r) => r.id === tried.region) ? tried.region : void 0;
+  const country = !choices.countries || tried.country !== void 0 && choices.countries.includes(tried.country) ? tried.country : void 0;
+  const channel = !choices.channels || choices.channels.some((c) => c.id === tried.channel) ? tried.channel : void 0;
+  const initial = { ...region !== void 0 && { region }, ...country !== void 0 && { country }, ...channel !== void 0 && { channel } };
+  return Object.keys(initial).length > 0 ? initial : void 0;
+}
+async function resolveStoreSettings(options, choice) {
+  const { connector, context, loadChoice, saveChoice, onSaveError } = options;
+  if (!connector.storeSettings) return { status: "unsupported" };
+  const tried = choice ?? await Promise.resolve().then(loadChoice).catch(() => void 0);
+  let settings;
+  try {
+    settings = await connector.storeSettings(context, tried);
+  } catch (error) {
+    if (error instanceof StoreSettingsError && error.code === "choice_required") {
+      const offered = error.choices ?? {};
+      const initial = tried && narrowInitial(tried, offered);
+      return { status: "choose", choices: offered, ...initial && { initial } };
+    }
+    throw error;
+  }
+  if (choice) await Promise.resolve().then(() => saveChoice(choice)).catch((error) => onSaveError?.(error));
+  return { status: "ready", settings, ...tried && { choice: tried } };
+}
+
+// src/store-settings/map-store-settings.ts
+function withPricingContext(context, settings) {
+  const { pricingContext: _previous, ...rest } = context;
+  return settings.pricingContext ? { ...rest, pricingContext: settings.pricingContext } : rest;
+}
+function taxProviderProps(settings) {
+  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax };
+}
+
+// src/store-settings/use-store-settings.ts
+import { useCallback as useCallback2, useEffect, useRef, useState } from "react";
+var LOADING = { state: "loading" };
+function useStoreSettings(options) {
+  const { connector, context } = options;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const requestRef = useRef(0);
+  const [state, setState] = useState(LOADING);
+  const resolve = useCallback2((choice, from) => {
+    if (from !== void 0 && from !== requestRef.current) return;
+    const request = ++requestRef.current;
+    const current = () => request === requestRef.current;
+    setState(LOADING);
+    resolveStoreSettings(optionsRef.current, choice).then(
+      (result) => {
+        if (!current()) return;
+        if (result.status === "ready") setState({ state: "ready", settings: result.settings, choice: result.choice });
+        else if (result.status === "choose")
+          setState({ state: "choose", choices: result.choices, initial: result.initial, choose: (pick) => resolve(pick, request) });
+        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) });
+      }
+    );
+  }, []);
+  useEffect(() => {
+    resolve();
+    return () => {
+      requestRef.current += 1;
+    };
+  }, [connector, context, resolve]);
+  return state;
+}
+
+// src/rxdb/index.ts
+import { readFresh, countFresh, watchFresh } from "@tallyui/core/rxdb";
+
 // src/repository/create-repository.ts
 import { map } from "rxjs";
 function createRepository(collection) {
   return {
-    findById$(id) {
-      return collection.findOne(id).$.pipe(
+    findById$(id2) {
+      return collection.findOne(id2).$.pipe(
         map((doc) => doc ? doc.toJSON() : null)
       );
     },
@@ -213,15 +349,15 @@ function createRepository(collection) {
       const doc = await collection.insert(data);
       return doc.toJSON();
     },
-    async update(id, patch) {
-      const doc = await collection.findOne(id).exec();
-      if (!doc) throw new Error(`Document ${id} not found`);
+    async update(id2, patch) {
+      const doc = await collection.findOne(id2).exec();
+      if (!doc) throw new Error(`Document ${id2} not found`);
       const updated = await doc.incrementalPatch(patch);
       return updated.toJSON();
     },
-    async remove(id) {
-      const doc = await collection.findOne(id).exec();
-      if (!doc) throw new Error(`Document ${id} not found`);
+    async remove(id2) {
+      const doc = await collection.findOne(id2).exec();
+      if (!doc) throw new Error(`Document ${id2} not found`);
       await doc.remove();
     },
     async bulkCreate(items) {
@@ -236,12 +372,59 @@ function createRepository(collection) {
 
 // src/order/order-builder.ts
 import { BehaviorSubject } from "rxjs";
+import { resolvePrice } from "@tallyui/core";
+
+// src/order/allocate-order-discount.ts
+function allocateOrderDiscount(lineAmountsMinor, totalMinor) {
+  if (!Number.isSafeInteger(totalMinor) || totalMinor < 0 || !lineAmountsMinor.every(Number.isSafeInteger)) {
+    throw new RangeError("Amounts must be safe integers and the discount non-negative");
+  }
+  const weights = lineAmountsMinor.map((amount) => BigInt(Math.max(0, amount)));
+  const weightTotal = weights.reduce((sum, weight) => sum + weight, 0n);
+  const total = BigInt(totalMinor);
+  if (total > weightTotal) throw new RangeError("Order discount exceeds the lines it applies to");
+  if (total === 0n) return weights.map(() => 0);
+  const shares = weights.map((weight) => total * weight / weightTotal);
+  const remainders = weights.map((weight) => total * weight % weightTotal);
+  let leftover = total - shares.reduce((sum, share) => sum + share, 0n);
+  const ranked = remainders.map((_, index) => index).sort((a, b) => remainders[a] === remainders[b] ? a - b : remainders[a] > remainders[b] ? -1 : 1);
+  for (const index of ranked) {
+    if (leftover === 0n) break;
+    shares[index] += 1n;
+    leftover -= 1n;
+  }
+  return shares.map(Number);
+}
+
+// src/order/order-builder.ts
 var nextId = 0;
 function uid() {
   return `${Date.now()}-${++nextId}`;
 }
+function roundHalfAway(n) {
+  return Math.sign(n) * Math.round(Math.abs(n));
+}
+function sumLines(lines) {
+  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);
+  return { subtotalMinor: linesTotal - taxMinor, taxMinor, totalMinor: Math.max(0, linesTotal) };
+}
+function toDisplayMode(line, amountMinor, displayInclusive) {
+  if (line.taxInclusive === displayInclusive) return amountMinor;
+  const ratePpm = line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0);
+  const taxMinor = roundMicrosToMinor(taxMicros(amountMinor, ratePpm, line.taxInclusive));
+  return line.taxInclusive ? amountMinor - taxMinor : amountMinor + taxMinor;
+}
+function assertDisplayResidue(residue, convertedLines, conversions) {
+  const bound = convertedLines === 0 ? 0 : Math.floor(conversions / 2) + 1;
+  if (Math.abs(residue) > bound) throw new Error(`Display residue ${residue} exceeds its bound of ${bound} (ADR-063)`);
+}
 function createOrderBuilder(options) {
-  const { currency, taxContext } = options;
+  const { taxContext } = options;
+  const currency = options.currency.toUpperCase();
   const orderId = options.id ?? uid();
   let lineItems = [];
   let orderDiscounts = [];
@@ -250,65 +433,131 @@ function createOrderBuilder(options) {
   let note = "";
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const subject = new BehaviorSubject(buildOrder());
-  function recalculateLine(line) {
-    const gross = line.price * line.quantity;
-    const recalcedDiscounts = line.discounts.map((d) => ({
-      ...d,
-      amount: computeDiscountAmount(d, gross)
-    }));
-    const discountAmount = recalcedDiscounts.reduce((sum, d) => sum + d.amount, 0);
-    const afterDiscount = gross - discountAmount;
-    const tax = calculateTax(afterDiscount, line.taxRate, taxContext.pricesIncludeTax);
+  function recalculateLine(line, orderDiscountMinor = 0) {
+    const grossMinor = line.unitPriceMinor * line.quantity;
+    let remaining = grossMinor;
+    const recalcedDiscounts = line.discounts.map((d) => {
+      const amountMinor = Math.min(remaining, computeDiscountAmount(d, d.type === "percentage" ? grossMinor : remaining));
+      remaining -= amountMinor;
+      return { ...d, amountMinor };
+    });
+    const lineDiscountMinor = Math.min(grossMinor, recalcedDiscounts.reduce((sum, d) => sum + d.amountMinor, 0));
+    const discountMinor = lineDiscountMinor + orderDiscountMinor;
+    const netMinor = grossMinor - discountMinor;
+    const combinedRate = line.taxLines.reduce((sum, tax) => sum + tax.ratePpm, 0);
+    const inclusiveTax = line.taxInclusive ? taxMicros(netMinor, combinedRate, true) : 0n;
+    let allocatedTax = 0n;
+    const taxLines = line.taxLines.map((tax, index) => {
+      const micros = line.taxInclusive ? index === line.taxLines.length - 1 ? inclusiveTax - allocatedTax : combinedRate === 0 ? 0n : inclusiveTax * BigInt(tax.ratePpm) / BigInt(combinedRate) : taxMicros(netMinor, tax.ratePpm, false);
+      allocatedTax += micros;
+      return { ...tax, taxMicros: micros.toString() };
+    });
     return {
       ...line,
       discounts: recalcedDiscounts,
-      discountAmount,
-      taxAmount: tax.taxAmount,
-      lineTotal: taxContext.pricesIncludeTax ? afterDiscount : afterDiscount + tax.taxAmount
+      discountMinor,
+      orderDiscountMinor,
+      netMinor,
+      taxLines,
+      taxMicros: allocatedTax.toString()
     };
   }
   function computeDiscountAmount(discount, base) {
     if (discount.type === "percentage") {
-      return Math.round(base * discount.value / 100 * 100) / 100;
+      return Math.max(0, roundHalfAway(base * discount.value / 100));
     }
-    return Math.min(discount.value, base);
+    if (!Number.isInteger(discount.value)) throw new RangeError("Fixed discount must be integer minor units");
+    return Math.max(0, Math.min(discount.value, base));
   }
   function buildOrder() {
-    const subtotalLines = lineItems.reduce((sum, li) => {
-      const lineGross = li.price * li.quantity - li.discountAmount;
-      if (taxContext.pricesIncludeTax) {
-        const tax = calculateTax(lineGross, li.taxRate, true);
-        return sum + tax.priceExclTax;
-      }
-      return sum + lineGross;
-    }, 0);
-    const subtotal = Math.round(subtotalLines * 100) / 100;
-    const recalcedOrderDiscounts = orderDiscounts.map((d) => ({
-      ...d,
-      amount: computeDiscountAmount(d, subtotal)
-    }));
-    const discountTotal = lineItems.reduce((sum, li) => sum + li.discountAmount, 0) + recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
-    const taxTotal = lineItems.reduce((sum, li) => sum + li.taxAmount, 0);
-    const total = lineItems.reduce((sum, li) => sum + li.lineTotal, 0) - recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
-    const roundedTotal = Math.round(total * 100) / 100;
-    const paidAmount = payments.reduce((sum, p) => sum + p.amount, 0);
-    const balanceDue = Math.max(0, Math.round((roundedTotal - paidAmount) * 100) / 100);
-    const changeDue = Math.max(0, Math.round((paidAmount - roundedTotal) * 100) / 100);
+    const lineAmounts = lineItems.map((li) => li.netMinor);
+    const base = lineAmounts.reduce((sum, amount) => sum + Math.max(0, amount), 0);
+    let remaining = base;
+    const recalcedOrderDiscounts = orderDiscounts.map((d) => {
+      const amountMinor = Math.min(remaining, computeDiscountAmount(d, d.type === "percentage" ? base : remaining));
+      remaining -= amountMinor;
+      return { ...d, amountMinor };
+    });
+    const shares = allocateOrderDiscount(lineAmounts, recalcedOrderDiscounts.reduce((sum, d) => sum + d.amountMinor, 0));
+    const lines = lineItems.map((li, index) => recalculateLine(li, shares[index]));
+    const { subtotalMinor, taxMinor, totalMinor } = sumLines(lines);
+    const discountMinor = lines.reduce((sum, li) => sum + li.discountMinor, 0);
+    const taxInclusive = taxContext.pricesIncludeTax;
+    const figures = lines.map((li) => {
+      const returned = li.unitPriceMinor < 0;
+      const discounts = returned ? [] : li.discounts.map((d) => ({
+        discountId: d.id,
+        ...d.label !== void 0 ? { label: d.label } : {},
+        amountMinor: toDisplayMode(li, d.amountMinor, taxInclusive)
+      }));
+      const shareMinor = toDisplayMode(li, li.orderDiscountMinor, taxInclusive);
+      const remainingMinor = toDisplayMode(li, li.netMinor, taxInclusive);
+      const amountMinor = li.taxInclusive === taxInclusive && !returned ? li.unitPriceMinor * li.quantity : discounts.reduce((sum, d) => sum + d.amountMinor, remainingMinor + shareMinor);
+      return { line: { lineId: li.id, amountMinor, discounts }, shareMinor, remainingMinor, returned };
+    });
+    const displayLines = figures.map((f) => f.line);
+    const orderDiscountDisplay = figures.reduce((sum, f) => sum + f.shareMinor, 0);
+    const displayDiscount = displayLines.reduce(
+      (sum, line) => line.discounts.reduce((lineSum, d) => lineSum + d.amountMinor, sum),
+      orderDiscountDisplay
+    );
+    const displaySubtotal = (taxInclusive ? totalMinor : totalMinor - taxMinor) + displayDiscount;
+    const residue = displaySubtotal - displayLines.reduce((sum, line) => sum + line.amountMinor, 0);
+    const converted = lines.flatMap((li, index) => li.taxInclusive === taxInclusive ? [] : [index]);
+    const conversions = converted.reduce((count, index) => count + [
+      lines[index].netMinor,
+      lines[index].orderDiscountMinor,
+      ...lines[index].discounts.map((d) => d.amountMinor)
+    ].filter((x) => x !== 0).length, 0);
+    assertDisplayResidue(residue, converted.length, conversions);
+    let left = residue;
+    const takers = converted.filter((index) => !figures[index].returned);
+    for (const index of takers.sort((a, b) => figures[b].remainingMinor - figures[a].remainingMinor || a - b)) {
+      if (left === 0) break;
+      const take = left > 0 ? left : Math.max(left, -figures[index].remainingMinor);
+      displayLines[index].amountMinor += take;
+      left -= take;
+    }
+    if (left !== 0) throw new Error(`Display residue ${left} left over with no converted line to take it (ADR-063)`);
+    if (displayDiscount < 0) throw new Error(`Display discount ${displayDiscount} is negative (ADR-063)`);
+    for (const { line, shareMinor, returned } of figures) {
+      if (returned && line.discounts.length > 0) throw new Error(`Return line ${line.lineId} shows discount rows (ADR-063)`);
+      if (returned) continue;
+      const rows = line.discounts.reduce((sum, d) => sum + d.amountMinor, 0);
+      if (shareMinor < 0 || line.discounts.some((d) => d.amountMinor < 0) || line.amountMinor < rows + shareMinor) {
+        throw new Error(`Display line ${line.lineId} shows ${line.amountMinor}, less than its rows ${rows} and share ${shareMinor} (ADR-063)`);
+      }
+    }
+    const display = {
+      taxInclusive,
+      subtotalMinor: displaySubtotal,
+      discountMinor: displayDiscount,
+      taxMinor,
+      totalMinor,
+      lines: displayLines,
+      orderDiscountMinor: orderDiscountDisplay
+    };
+    const paidMinor = payments.reduce((sum, p) => sum + p.amountMinor, 0);
+    const balanceDueMinor = Math.max(0, totalMinor - paidMinor);
+    const changeDueMinor = Math.max(0, paidMinor - totalMinor);
     return {
       id: orderId,
       status: "draft",
-      lineItems: [...lineItems],
+      lineItems: lines,
       discounts: recalcedOrderDiscounts,
       payments: [...payments],
       customer,
       note,
-      subtotal,
-      discountTotal: Math.round(discountTotal * 100) / 100,
-      taxTotal: Math.round(taxTotal * 100) / 100,
-      total: roundedTotal,
-      balanceDue,
-      changeDue,
+      subtotalMinor,
+      discountMinor,
+      taxMinor,
+      totalMinor,
+      display,
+      paidMinor,
+      balanceDueMinor,
+      changeDueMinor,
       currency,
+      pricesIncludeTax: taxContext.pricesIncludeTax,
       createdAt: now,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -316,45 +565,72 @@ function createOrderBuilder(options) {
   function emit() {
     subject.next(buildOrder());
   }
+  function addLine(input) {
+    const { productId, variantId, unitPrice } = input;
+    const quantity = input.quantity ?? 1;
+    if (unitPrice.currency !== currency) throw new RangeError("Line currency must match " + currency);
+    if (!Number.isInteger(unitPrice.amount)) throw new RangeError("Price must be integer minor units");
+    if (!Number.isInteger(quantity) || quantity < 1) throw new RangeError("Quantity must be an integer >= 1");
+    const taxRates = input.taxRates ?? [{ ratePpm: taxContext.getTaxRatePpm() }];
+    const taxInclusive = unitPrice.taxInclusive ?? taxContext.pricesIncludeTax;
+    const existing = lineItems.find(
+      (li) => li.productId === productId && li.variantId === variantId && li.taxInclusive === taxInclusive && li.unitPriceMinor === unitPrice.amount && li.taxLines.length === taxRates.length && li.taxLines.every((tax, index) => tax.code === taxRates[index].code && tax.ratePpm === taxRates[index].ratePpm)
+    );
+    if (existing) {
+      lineItems = lineItems.map(
+        (li) => li.id === existing.id ? recalculateLine({ ...li, quantity: li.quantity + quantity }) : li
+      );
+      emit();
+      return existing.id;
+    }
+    const lineId = uid();
+    const line = {
+      id: lineId,
+      productId,
+      variantId,
+      name: input.name,
+      sku: input.sku ?? "",
+      imageUrl: input.imageUrl,
+      unitPriceMinor: unitPrice.amount,
+      quantity,
+      taxLines: taxRates.map((tax) => ({ ...tax, taxMicros: "0" })),
+      discounts: [],
+      discountMinor: 0,
+      orderDiscountMinor: 0,
+      netMinor: 0,
+      taxMicros: "0",
+      taxInclusive,
+      // TV4b derives the store-level flag with Medusa's own precedence (region
+      // preference, then currency), so a disagreement should be rare. It can
+      // still happen, for example when a price preference changes after the
+      // settings were read. Keeping the line in its own mode means the customer
+      // pays exactly the shelf price, as Medusa's checkout would.
+      ...taxInclusive !== taxContext.pricesIncludeTax ? { priceTaxModeConverted: taxInclusive ? "inclusive-to-exclusive" : "exclusive-to-inclusive" } : {}
+    };
+    lineItems = [...lineItems, recalculateLine(line)];
+    emit();
+    return lineId;
+  }
   return {
     order$: subject.asObservable(),
+    addLine,
     addProduct(doc, traits, opts) {
       const productId = traits.getId(doc);
-      const variantId = opts?.variantId;
-      const quantity = opts?.quantity ?? 1;
-      const existing = lineItems.find(
-        (li) => li.productId === productId && li.variantId === variantId
-      );
-      if (existing) {
-        existing.quantity += quantity;
-        lineItems = lineItems.map(
-          (li) => li.id === existing.id ? recalculateLine(existing) : li
-        );
-        emit();
-        return existing.id;
-      }
-      const priceStr = traits.getPrice(doc);
-      const price = priceStr ? parseFloat(priceStr) : 0;
-      const taxRate = taxContext.getTaxRate();
-      const lineId = uid();
-      const line = {
-        id: lineId,
+      if (!traits.isSellable(doc)) throw new Error("addProduct: this product isn't sold in this store's channel");
+      const variant = opts?.variantId !== void 0 && traits.getVariants ? traits.getVariants(doc, { currency }).find((variant2) => variant2.id === opts.variantId) : void 0;
+      if (opts?.variantId !== void 0 && traits.getVariants && !variant)
+        throw new Error(`Unknown variant ${opts.variantId} for product ${productId}`);
+      const unitPrice = resolvePrice(variant ? variant.prices : traits.getPrices(doc, { currency }), currency)?.current;
+      if (!unitPrice) throw new Error("No price in " + currency + " for product " + productId);
+      return addLine({
         productId,
-        variantId,
+        variantId: opts?.variantId,
         name: traits.getName(doc),
-        sku: traits.getSku(doc) ?? "",
+        sku: variant?.sku ?? traits.getSku(doc),
         imageUrl: traits.getImageUrl(doc),
-        price,
-        quantity,
-        taxRate,
-        taxAmount: 0,
-        discounts: [],
-        discountAmount: 0,
-        lineTotal: 0
-      };
-      lineItems = [...lineItems, recalculateLine(line)];
-      emit();
-      return lineId;
+        unitPrice,
+        quantity: opts?.quantity
+      });
     },
     updateQuantity(lineId, quantity) {
       if (quantity <= 0) {
@@ -373,11 +649,11 @@ function createOrderBuilder(options) {
     applyLineDiscount(lineId, discount) {
       lineItems = lineItems.map((li) => {
         if (li.id !== lineId) return li;
-        const base = li.price * li.quantity;
+        const base = li.unitPriceMinor * li.quantity;
         const applied = {
           ...discount,
           id: uid(),
-          amount: computeDiscountAmount(discount, base)
+          amountMinor: computeDiscountAmount(discount, base)
         };
         return recalculateLine({ ...li, discounts: [...li.discounts, applied] });
       });
@@ -387,7 +663,7 @@ function createOrderBuilder(options) {
       const applied = {
         ...discount,
         id: uid(),
-        amount: 0
+        amountMinor: computeDiscountAmount(discount, 0)
       };
       orderDiscounts = [...orderDiscounts, applied];
       emit();
@@ -404,10 +680,10 @@ function createOrderBuilder(options) {
       emit();
     },
     addPayment(payment) {
-      const id = uid();
-      payments = [...payments, { ...payment, id }];
+      const id2 = uid();
+      payments = [...payments, { ...payment, id: id2 }];
       emit();
-      return id;
+      return id2;
     },
     removePayment(paymentId) {
       payments = payments.filter((p) => p.id !== paymentId);
@@ -438,7 +714,8 @@ function createOrderBuilder(options) {
 // src/order/order-manager.ts
 import { BehaviorSubject as BehaviorSubject2, map as map2 } from "rxjs";
 function createOrderManager(options) {
-  const { currency, taxContext, draftsCollection } = options;
+  const { taxContext, draftsCollection } = options;
+  const currency = options.currency.toUpperCase();
   let activeBuilder = createOrderBuilder({ currency, taxContext });
   const activeSubject = new BehaviorSubject2(activeBuilder);
   const parkedOrders$ = draftsCollection.find().$.pipe(
@@ -449,7 +726,7 @@ function createOrderManager(options) {
           id: json.id,
           customerName: json.customerName || void 0,
           itemCount: json.itemCount ?? 0,
-          total: json.total ?? 0,
+          totalMinor: json.total ?? 0,
           parkedAt: json.parkedAt ?? "",
           source: "local"
         };
@@ -471,7 +748,7 @@ function createOrderManager(options) {
         data: JSON.stringify(snapshot),
         customerName: snapshot.customer?.name ?? "",
         itemCount: snapshot.lineItems.length,
-        total: snapshot.total,
+        total: snapshot.totalMinor,
         parkedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       activeBuilder = createOrderBuilder({ currency, taxContext });
@@ -495,43 +772,23 @@ function createOrderManager(options) {
         builder.setNote(savedOrder.note);
       }
       for (const line of savedOrder.lineItems) {
-        const syntheticTraits = {
-          getId: (d) => d.productId,
-          getName: (d) => d.name,
-          getSku: (d) => d.sku,
-          getPrice: (d) => String(d.price),
-          getRegularPrice: (d) => String(d.price),
-          getSalePrice: () => void 0,
-          isOnSale: () => false,
-          getImageUrl: (d) => d.imageUrl,
-          getImageUrls: (d) => d.imageUrl ? [d.imageUrl] : [],
-          getDescription: () => void 0,
-          getStockStatus: () => "instock",
-          getStockQuantity: () => null,
-          hasVariants: () => false,
-          getType: () => "simple",
-          getBarcode: () => void 0,
-          getCategoryNames: () => []
-        };
-        builder.addProduct(line, syntheticTraits, {
+        const lineId = builder.addLine({
+          productId: line.productId,
           variantId: line.variantId,
-          quantity: line.quantity
+          name: line.name,
+          sku: line.sku,
+          imageUrl: line.imageUrl,
+          unitPrice: { amount: line.unitPriceMinor, currency, taxInclusive: line.taxInclusive },
+          quantity: line.quantity,
+          taxRates: line.taxLines.map(({ code, ratePpm }) => ({ code, ratePpm }))
         });
-      }
-      const resumedOrder = builder.getSnapshot();
-      for (const savedLine of savedOrder.lineItems) {
-        const newLine = resumedOrder.lineItems.find(
-          (li) => li.productId === savedLine.productId && li.variantId === savedLine.variantId
-        );
-        if (newLine) {
-          for (const discount of savedLine.discounts) {
-            builder.applyLineDiscount(newLine.id, {
-              type: discount.type,
-              value: discount.value,
-              label: discount.label,
-              couponCode: discount.couponCode
-            });
-          }
+        for (const discount of line.discounts) {
+          builder.applyLineDiscount(lineId, {
+            type: discount.type,
+            value: discount.value,
+            label: discount.label,
+            couponCode: discount.couponCode
+          });
         }
       }
       for (const discount of savedOrder.discounts) {
@@ -545,7 +802,9 @@ function createOrderManager(options) {
       for (const payment of savedOrder.payments) {
         builder.addPayment({
           method: payment.method,
-          amount: payment.amount,
+          amountMinor: payment.amountMinor,
+          tenderedMinor: payment.tenderedMinor,
+          changeMinor: payment.changeMinor,
           reference: payment.reference
         });
       }
@@ -563,16 +822,20 @@ function createOrderManager(options) {
 
 // src/receipt/build-receipt-data.ts
 function buildReceiptData(order, config) {
-  const taxByRate = /* @__PURE__ */ new Map();
-  for (const line of order.lineItems) {
-    const existing = taxByRate.get(line.taxRate) ?? 0;
-    taxByRate.set(line.taxRate, existing + line.taxAmount);
-  }
-  const taxLines = Array.from(taxByRate.entries()).map(([rate, amount]) => ({
-    label: config.taxLabels?.[rate] ?? `Tax ${Math.round(rate * 100)}%`,
-    rate,
-    amount: Math.round(amount * 100) / 100
-  }));
+  const taxLines = taxLinesByRate(order.lineItems, order.taxMinor, config.taxLabels).map(
+    ({ label: label2, code, ratePpm, amountMinor }) => ({ label: label2, code, ratePpm, amountMinor })
+  );
+  let taxSoFar = order.lineItems.reduce(
+    (sum, li) => li.taxInclusive || li.priceTaxModeConverted ? sum : sum + BigInt(li.taxMicros),
+    0n
+  );
+  const lineTotals = order.lineItems.map((li) => {
+    if (!li.priceTaxModeConverted) return li.netMinor;
+    const share = roundMicrosToMinor(taxSoFar + BigInt(li.taxMicros)) - roundMicrosToMinor(taxSoFar);
+    taxSoFar += BigInt(li.taxMicros);
+    return li.taxInclusive ? li.netMinor - share : li.netMinor + share;
+  });
+  const label = (d) => d.label ?? d.couponCode ?? `${d.type} discount`;
   return {
     header: {
       storeName: config.storeName,
@@ -582,30 +845,36 @@ function buildReceiptData(order, config) {
       cashier: config.cashier,
       register: config.register
     },
-    lineItems: order.lineItems.map((li) => ({
+    lineItems: order.lineItems.map((li, index) => ({
       name: li.name,
       sku: li.sku,
       quantity: li.quantity,
-      unitPrice: li.price,
-      lineTotal: li.lineTotal
+      unitPriceMinor: li.unitPriceMinor,
+      lineTotalMinor: lineTotals[index],
+      // Line plus allocated order discounts, in the line's own mode; lineTotalMinor is already after it (ADR-062).
+      ...li.discountMinor > 0 ? { discountMinor: li.discountMinor } : {},
+      displayAmountMinor: order.display.lines[index].amountMinor,
+      displayDiscounts: order.display.lines[index].discounts.map((row, i) => ({ label: label(li.discounts[i]), amountMinor: row.amountMinor }))
     })),
     discounts: order.discounts.map((d) => ({
-      label: d.label ?? d.couponCode ?? `${d.type} discount`,
-      amount: d.amount
+      label: label(d),
+      amountMinor: d.amountMinor
     })),
+    orderDiscountMinor: order.display.orderDiscountMinor,
     totals: {
-      subtotal: order.subtotal,
-      discountTotal: order.discountTotal,
+      taxInclusive: order.display.taxInclusive,
+      subtotalMinor: order.display.subtotalMinor,
+      discountMinor: order.display.discountMinor,
       taxLines,
-      taxTotal: order.taxTotal,
-      total: order.total
+      taxMinor: order.display.taxMinor,
+      totalMinor: order.display.totalMinor
     },
     payments: order.payments.map((p) => ({
       method: p.method,
-      amount: p.amount,
+      amountMinor: p.amountMinor,
       reference: p.reference
     })),
-    changeDue: order.changeDue,
+    changeDueMinor: order.changeDueMinor,
     footer: {
       note: order.note || void 0,
       barcode: order.id
@@ -613,20 +882,2969 @@ function buildReceiptData(order, config) {
     currency: order.currency
   };
 }
+
+// src/product/search-products.ts
+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 exact = docs.filter((doc) => codes(doc).includes(query));
+  if (exact.length) return exact;
+  const words = query.split(/\s+/);
+  return docs.filter((doc) => {
+    const haystack = [traits.getName(doc).toLowerCase(), ...codes(doc)].join(" ");
+    return words.every((word) => haystack.includes(word));
+  });
+}
+
+// src/product/stock.ts
+import { map as map3 } from "rxjs";
+import { STOCK_LEVELS_LAST_PASS } from "@tallyui/core";
+import { withStockOverlay, getProductStock } from "@tallyui/core";
+function stockOverlay$(collection) {
+  return collection.find().$.pipe(
+    map3((rows) => new Map(rows.map((row) => [row.primary, row.get("value")])))
+  );
+}
+function stockOverlayAsOf$(collection) {
+  return collection.getLocal$(STOCK_LEVELS_LAST_PASS).pipe(
+    map3((doc) => doc?.get("completedAt"))
+  );
+}
+
+// src/sale/use-sale.ts
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+
+// src/pos-order/uuidv7.ts
+function format(ms, bytes) {
+  let timestamp = BigInt(ms);
+  for (let i = 5; i >= 0; i--) {
+    bytes[i] = Number(timestamp & 0xffn);
+    timestamp >>= 8n;
+  }
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function createUuidv7(options) {
+  let lastMs = -Infinity;
+  let lastRand = 0n;
+  return () => {
+    const randomBytes = options?.randomBytes;
+    if (!randomBytes && !globalThis.crypto?.getRandomValues) throw new Error("uuidv7: no random source");
+    let ms = Math.max((options?.now ?? Date.now)(), lastMs);
+    let rand = lastRand + 1n;
+    if (ms === lastMs && rand === 2n ** 74n) ms = lastMs + 1;
+    if (ms !== lastMs) {
+      const bytes2 = randomBytes ? randomBytes(16) : globalThis.crypto.getRandomValues(new Uint8Array(16));
+      rand = BigInt(bytes2[6] & 15) << 8n | BigInt(bytes2[7]);
+      rand = rand << 6n | BigInt(bytes2[8] & 63);
+      for (let i = 9; i < 16; i++) rand = rand << 8n | BigInt(bytes2[i]);
+    }
+    lastMs = ms;
+    lastRand = rand;
+    const bytes = new Uint8Array(16);
+    for (let i = 15; i >= 9; i--) {
+      bytes[i] = Number(rand & 0xffn);
+      rand >>= 8n;
+    }
+    bytes[8] = Number(rand & 0x3fn);
+    rand >>= 6n;
+    bytes[7] = Number(rand & 0xffn);
+    bytes[6] = Number(rand >> 8n);
+    return format(ms, bytes);
+  };
+}
+var monotonic = createUuidv7();
+function uuidv7(now, randomBytes) {
+  if (now === void 0 && randomBytes === void 0) return monotonic();
+  const ms = now ?? Date.now();
+  if (!randomBytes && !globalThis.crypto?.getRandomValues) throw new Error("uuidv7: no random source");
+  return format(ms, randomBytes ? randomBytes(16) : globalThis.crypto.getRandomValues(new Uint8Array(16)));
+}
+
+// src/pos-order/finalize.ts
+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)) {
+    throw new Error("finalize: negative discount");
+  }
+  const hasDiscount = order.discountMinor !== 0 || order.lineItems.some((line) => line.discountMinor !== 0) || order.discounts.some((d) => d.amountMinor !== 0);
+  if (hasDiscount && (options.capabilities?.orderCreate ?? 1) < 2) {
+    throw new Error("finalize: discounts are not supported by the server yet (order.create v2)");
+  }
+  for (const payment of order.payments) {
+    if (payment.method !== "cash" && payment.method !== "external") {
+      throw new Error(`finalize: unsupported payment method ${payment.method}`);
+    }
+  }
+  if (order.paidMinor < order.totalMinor) throw new Error("finalize: underpaid");
+  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 newId = options.newId ?? uuidv7;
+  const id2 = newId();
+  const lines = order.lineItems.map((line) => ({
+    id: newId(),
+    productId: line.productId,
+    ...line.variantId !== void 0 ? { variantId: line.variantId } : {},
+    name: line.name,
+    sku: line.sku,
+    quantity: line.quantity,
+    unitPriceMinor: line.unitPriceMinor,
+    discountMinor: line.discountMinor,
+    netMinor: line.netMinor,
+    taxLines: line.taxLines.map((tax) => ({ ...tax })),
+    ...line.priceTaxModeConverted ? { taxInclusive: line.taxInclusive } : {}
+  }));
+  const payments = order.payments.map((payment) => ({
+    id: newId(),
+    method: payment.method,
+    amountMinor: payment.amountMinor,
+    ...payment.reference !== void 0 ? { reference: payment.reference } : {}
+  }));
+  for (let i = payments.length - 1; i >= 0; i--) {
+    const payment = payments[i];
+    if (payment.method !== "cash") continue;
+    payment.tenderedMinor = payment.amountMinor;
+    payment.changeMinor = Math.min(change, payment.tenderedMinor);
+    payment.amountMinor -= payment.changeMinor;
+    change -= payment.changeMinor;
+  }
+  if (payments.reduce((sum, p) => sum + p.amountMinor, 0) !== order.totalMinor) {
+    throw new Error("finalize: payments do not reconcile");
+  }
+  const now = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: id2,
+    createdAt: now,
+    updatedAt: now,
+    commandId: newId(),
+    syncStatus: "pending",
+    currency: order.currency,
+    pricesIncludeTax: order.pricesIncludeTax,
+    lines,
+    payments,
+    subtotalMinor: order.subtotalMinor,
+    discountMinor: order.discountMinor,
+    taxMinor: order.taxMinor,
+    totalMinor: order.totalMinor,
+    customer: order.customer ? {
+      id: order.customer.id,
+      name: order.customer.name,
+      ...order.customer.email !== void 0 ? { email: order.customer.email } : {}
+    } : 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 } : {}
+    }
+  };
+}
+
+// src/pos-order/schema.ts
+import { addRxPlugin } from "rxdb";
+import { RxDBMigrationSchemaPlugin } from "rxdb/plugins/migration-schema";
+var posOrderSchema = {
+  version: 2,
+  primaryKey: "id",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: { type: "string", maxLength: 36 },
+    commandId: { type: "string", maxLength: 36 },
+    createdAt: { type: "string", maxLength: 40 },
+    updatedAt: { type: "string" },
+    currency: { type: "string" },
+    pricesIncludeTax: { type: "boolean" },
+    subtotalMinor: { type: "integer" },
+    discountMinor: { type: "integer" },
+    taxMinor: { type: "integer" },
+    totalMinor: { type: "integer" },
+    syncStatus: { type: "string", enum: ["pending", "applied", "rejected"], maxLength: 10 },
+    note: { type: "string" },
+    registerId: { type: "string" },
+    sessionId: { type: "string" },
+    cashierRef: { type: "string" },
+    lines: { type: "array", items: {
+      type: "object",
+      properties: {
+        id: { type: "string", maxLength: 36 },
+        productId: { type: "string" },
+        variantId: { type: "string" },
+        name: { type: "string" },
+        sku: { type: "string" },
+        quantity: { type: "integer" },
+        unitPriceMinor: { type: "integer" },
+        discountMinor: { type: "integer" },
+        netMinor: { type: "integer" },
+        taxLines: { type: "array", items: {
+          type: "object",
+          properties: { code: { type: "string" }, ratePpm: { type: "integer" }, taxMicros: { type: "string" } },
+          required: ["ratePpm", "taxMicros"]
+        } }
+      },
+      required: ["id", "productId", "name", "sku", "quantity", "unitPriceMinor", "discountMinor", "netMinor", "taxLines"]
+    } },
+    payments: { type: "array", items: {
+      type: "object",
+      properties: {
+        id: { type: "string", maxLength: 36 },
+        method: { type: "string", enum: ["cash", "external"] },
+        amountMinor: { type: "integer" },
+        tenderedMinor: { type: "integer" },
+        changeMinor: { type: "integer" },
+        reference: { type: "string" }
+      },
+      required: ["id", "method", "amountMinor"]
+    } },
+    customer: { type: ["object", "null"], properties: { id: { type: "string" }, name: { type: "string" }, email: { type: "string" } } },
+    serverRefs: { type: "object", properties: {
+      orderId: { type: "string" },
+      displayId: { type: "string" },
+      totalMinor: { type: "integer" }
+    }, required: ["orderId", "totalMinor"] },
+    warnings: { type: "array", items: {
+      type: "object",
+      properties: { code: { type: "string", maxLength: 64 } },
+      required: ["code"],
+      additionalProperties: true
+    } },
+    error: { type: "object", properties: { code: { type: "string" }, message: { type: "string" } }, required: ["code", "message"] },
+    lateSessionId: { type: "string" },
+    // 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" },
+      exponent: { type: "integer" },
+      taxInclusive: { type: "boolean" },
+      subtotalMinor: { type: "integer" },
+      discountMinor: { type: "integer" },
+      taxMinor: { type: "integer" },
+      totalMinor: { type: "integer" },
+      orderDiscountMinor: { type: "integer" },
+      lines: { type: "array", items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          lineId: { type: "string" },
+          amountMinor: { type: "integer" },
+          discounts: { type: "array", items: {
+            type: "object",
+            additionalProperties: false,
+            properties: { discountId: { type: "string" }, label: { type: "string" }, amountMinor: { type: "integer" } },
+            required: ["discountId", "amountMinor"]
+          } }
+        },
+        required: ["lineId", "amountMinor", "discounts"]
+      } }
+    }, required: ["currency", "exponent", "taxInclusive", "subtotalMinor", "discountMinor", "taxMinor", "totalMinor", "orderDiscountMinor", "lines"] },
+    taxByRate: { type: "array", items: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ratePpm: { type: "integer" },
+        code: { type: "string" },
+        label: { type: "string" },
+        netMinor: { type: "integer" },
+        amountMinor: { type: "integer" },
+        grossMinor: { type: "integer" }
+      },
+      required: ["ratePpm", "netMinor", "amountMinor", "grossMinor"]
+    } }
+  },
+  required: [
+    "id",
+    "createdAt",
+    "currency",
+    "pricesIncludeTax",
+    "lines",
+    "subtotalMinor",
+    "discountMinor",
+    "taxMinor",
+    "totalMinor",
+    "payments",
+    "customer",
+    "syncStatus",
+    "commandId",
+    "updatedAt"
+  ],
+  indexes: ["createdAt", "syncStatus", ["syncStatus", "createdAt"]]
+};
+function posOrderCollection() {
+  addRxPlugin(RxDBMigrationSchemaPlugin);
+  const identity2 = (doc) => doc;
+  return { schema: posOrderSchema, migrationStrategies: { 1: identity2, 2: identity2 } };
+}
+
+// src/pos-order/open.ts
+import {
+  deepEqual,
+  defaultConflictHandler,
+  getChangedDocumentsSince,
+  getRxReplicationMetaInstanceSchema,
+  getSingleDocument,
+  hasEncryption,
+  newRxError,
+  overwritable,
+  rxStorageInstanceToReplicationHandler
+} from "rxdb";
+import { getOldCollectionMeta, migrateDocumentData } from "rxdb/plugins/migration-schema";
+import { Subject, takeUntil } from "rxjs";
+var posOrdersLogger = createLogger("pos-orders");
+var POS_ORDER_MIGRATION_CLOSE_WAIT_MS = 1e4;
+var PosOrderOpenClosedError = class extends Error {
+  constructor(databaseName) {
+    super(`addPosOrderCollection: database ${databaseName} closed during the open; reopen it and open pos_orders again`);
+    this.databaseName = databaseName;
+    this.name = "PosOrderOpenClosedError";
+  }
+  code = "POS_ORDER_OPEN_CLOSED";
+};
+var latestOpens = /* @__PURE__ */ new WeakMap();
+var closedUnderOpen = /* @__PURE__ */ new WeakSet();
+function waitWithTimeout(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), ms);
+    promise.finally(() => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+}
+async function writeOverStaleCopies(collection, from, to) {
+  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)) {
+    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));
+    if (stale.length > 0) await handler.masterWrite(stale);
+  }
+}
+async function addPosOrderCollection(db, closeWaitMs = POS_ORDER_MIGRATION_CLOSE_WAIT_MS) {
+  if (db.multiInstance) throw new Error("addPosOrderCollection: multiInstance databases are not supported (ADR-061)");
+  if (db.closed || db.closePromise) throw new PosOrderOpenClosedError(db.name);
+  const previous = latestOpens.get(db);
+  if (!previous) {
+    db.onClose.push(() => waitWithTimeout(latestOpens.get(db), closeWaitMs).then((settled) => {
+      if (!settled) closedUnderOpen.add(db);
+    }));
+  }
+  const opening = openPosOrders(db, previous);
+  latestOpens.set(db, Promise.all([previous, opening.catch(() => void 0)]));
+  return opening;
+}
+async function openPosOrders(db, previous) {
+  const closing = () => closedUnderOpen.has(db) || db.closed;
+  const stopIfClosing = () => {
+    if (closing()) throw new PosOrderOpenClosedError(db.name);
+  };
+  const { pos_orders: collection } = await db.addCollections({ pos_orders: { ...posOrderCollection(), autoMigrate: false } });
+  const state = collection.getMigrationState();
+  try {
+    stopIfClosing();
+    const mustMigrate = await state.mustMigrate;
+    stopIfClosing();
+    if (!mustMigrate) return collection;
+    await previous;
+    stopIfClosing();
+    await state.updateStatus((status2) => {
+      delete status2.error;
+      status2.status = "RUNNING";
+      status2.count = { total: 0, handled: 0, percent: 0 };
+      return status2;
+    });
+    const old = (await state.oldCollectionMeta).data.schema;
+    stopIfClosing();
+    const checkpoint = await db.storage.createStorageInstance({
+      databaseName: db.name,
+      collectionName: `rx-migration-state-meta-pos_orders-${old.version}`,
+      databaseInstanceToken: db.token,
+      multiInstance: db.multiInstance,
+      options: {},
+      password: db.password,
+      schema: getRxReplicationMetaInstanceSchema(old, hasEncryption(old)),
+      devMode: overwritable.isDevMode()
+    });
+    await (closing() ? checkpoint.close() : checkpoint.remove());
+    stopIfClosing();
+    const settled = new Subject();
+    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);
+    } });
+    const internalStore = gate(db.internalStore, async (key, first) => {
+      const ids = key === "bulkWrite" ? first.map((row) => row.document.id) : first;
+      posOrdersLogger.warn(
+        `The database closed during the migration: dropped a ${key === "bulkWrite" ? "status write" : "status read"}`,
+        { database: db.name, ids }
+      );
+      return key === "bulkWrite" ? { error: [] } : [];
+    });
+    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) => {
+      const to = gate(current, () => Promise.reject(new PosOrderOpenClosedError(db.name)));
+      if (from.collectionName === collection.name) await writeOverStaleCopies(collection, from, to);
+      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());
+    stopIfClosing();
+    const status = (await getSingleDocument(db.internalStore, state.statusDocId))?.data;
+    stopIfClosing();
+    const oldMeta = status?.status === "DONE" ? await getOldCollectionMeta(state) : void 0;
+    stopIfClosing();
+    if (status?.status === "DONE" && !oldMeta) return collection;
+    throw newRxError("DM4", { collection: collection.name, error: status?.error });
+  } catch (error) {
+    await collection.close();
+    throw closing() ? new PosOrderOpenClosedError(db.name) : error;
+  }
+}
+
+// src/pos-order/device-id.ts
+var processId;
+function getDeviceId(storage, key) {
+  try {
+    if (storage) {
+      const existing = storage.getItem(key);
+      if (existing) return existing;
+      const id2 = uuidv7();
+      storage.setItem(key, id2);
+      return id2;
+    }
+  } catch {
+  }
+  return processId ??= uuidv7();
+}
+
+// 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));
+}
+
+// src/pos-order/same-sale.ts
+function sameSale(stored, retried) {
+  return stored.totalMinor === retried.totalMinor && stored.currency === retried.currency && stored.lines.length === retried.lines.length && stored.lines.every((line, i) => {
+    const other = retried.lines[i];
+    return line.id === other.id && line.quantity === other.quantity && line.netMinor === other.netMinor;
+  }) && stored.payments.length === retried.payments.length && stored.payments.every((payment, i) => payment.method === retried.payments[i].method && payment.amountMinor === retried.payments[i].amountMinor);
+}
+var OrderContentMismatchError = class extends Error {
+  constructor(orderId) {
+    super(`Order ${orderId} is already stored with different content`);
+    this.orderId = orderId;
+    this.name = "OrderContentMismatchError";
+  }
+};
+
+// src/register/movement-input.ts
+var SERVER_DECIMAL = /^\d+(?:\.\d+)?$/;
+var MAX_INTEGER_DIGITS = 15;
+var MAX_REASON_LENGTH = 500;
+var KEYPAD_DECIMAL_COMMA = /^(\d+),(\d{1,2})$/;
+function normalizeAmount(raw) {
+  const trimmed = raw.trim();
+  const dotted = trimmed.replace(KEYPAD_DECIMAL_COMMA, "$1.$2");
+  return dotted.replace(/^\./, "0.").replace(/\.$/, "");
+}
+function isServerDecimal(value) {
+  if (!SERVER_DECIMAL.test(value)) return false;
+  return value.split(".")[0].replace(/^0+/, "").length <= MAX_INTEGER_DIGITS;
+}
+function movementFieldError(input) {
+  if (input.type !== "no_sale") {
+    const amount = normalizeAmount(input.amount);
+    if (!isServerDecimal(amount) || Number(amount) <= 0) return "amount";
+  }
+  const reason = input.reason.trim();
+  if (!reason || reason.length > MAX_REASON_LENGTH) return "reason";
+  return null;
+}
+
+// src/register/expected.ts
+function deriveExpected({
+  session,
+  movements,
+  ledgerRowsBySession
+}) {
+  const totals = { cash: session.countedFloatMinor };
+  for (const row of ledgerRowsBySession) {
+    if (row.session_id !== session.id || row.status !== "captured") continue;
+    const method = row.kind === "cash" ? "cash" : row.method_id;
+    totals[method] = (totals[method] ?? 0) + row.amountMinor;
+  }
+  const voids = new Set(
+    movements.filter((row) => row.session_id === session.id && row.type === "void").map((row) => row.voids)
+  );
+  for (const row of movements) {
+    if (row.session_id !== session.id || row.voided_by || voids.has(row.id)) continue;
+    if (row.type === "paid_in") totals.cash += row.amountMinor;
+    if (row.type === "paid_out") totals.cash -= row.amountMinor;
+  }
+  return totals;
+}
+
+// src/register/register-count.helpers.ts
+function parseMinor(text2, exponent) {
+  const [whole, fraction = ""] = text2.trim().split(".");
+  if (fraction.length > exponent) return NaN;
+  return Number(whole || "0") * 10 ** exponent + Number(fraction.padEnd(exponent, "0") || "0");
+}
+var validAmount = (value, exponent) => /^(?:\d+\.?\d*|\.\d+)$/.test(value) && Number.isFinite(Number(value)) && Number.isSafeInteger(parseMinor(value, exponent));
+var countVariance = (countedMinor, expectedMinor) => countedMinor - expectedMinor;
+var overThreshold = (variance, thresholdMinor) => thresholdMinor != null && Math.abs(variance) > thresholdMinor;
+var closeNeedsApproval = (countedCashMinor, expectedCashMinor, thresholdMinor) => overThreshold(countVariance(countedCashMinor, expectedCashMinor), thresholdMinor);
+var denominationTotal = (pieces) => Object.entries(pieces).reduce((sum, [value, count]) => sum + Number(value) * count, 0);
+function varianceText(variance, exponent, format2, t) {
+  if (!variance) return t("register.exact");
+  return `${format2(Math.abs(variance) / 10 ** exponent)} ${t(variance < 0 ? "register.short" : "register.over")}`;
+}
+
+// src/register/register-count.denominations.ts
+var coinsMinor = [200, 100, 50, 20, 10, 5, 2, 1];
+var denominations = {
+  GBP: [5e3, 2e3, 1e3, 500, ...coinsMinor],
+  EUR: [5e4, 2e4, 1e4, 5e3, 2e3, 1e3, 500, ...coinsMinor],
+  USD: [1e4, 5e3, 2e3, 1e3, 500, 100, 25, 10, 5, 1],
+  default: [1e4, 5e3, 2e3, 1e3, 500, 200, 100, 50, 25, 10, 5, 1]
+};
+
+// src/register/schemas.ts
+import { addRxPlugin as addRxPlugin2 } from "rxdb";
+import { RxDBLocalDocumentsPlugin } from "rxdb/plugins/local-documents";
+var id = { type: "string", maxLength: 36 };
+var text = { type: "string" };
+var nullableText = { type: ["string", "null"] };
+var minor = { type: "integer" };
+var nullableMinor = { type: ["integer", "null"] };
+var tenders = { type: "object", additionalProperties: minor };
+var registerSessionSchema = {
+  title: "Register sessions",
+  version: 0,
+  primaryKey: "id",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id,
+    register_id: id,
+    store_key: nullableText,
+    status: { type: "string", enum: ["open", "counting", "closed"], maxLength: 8 },
+    business_day: { type: "string", maxLength: 10 },
+    opened_at_gmt: text,
+    opened_by: nullableText,
+    expected_float_minor: nullableMinor,
+    counted_float_minor: minor,
+    opening_variance_minor: nullableMinor,
+    counting_started_at_gmt: nullableText,
+    closed_at_gmt: nullableText,
+    closed_by: nullableText,
+    approval_required: { type: "boolean", default: false },
+    approved_by: nullableText,
+    counted: { type: ["object", "null"], additionalProperties: minor },
+    closure_id: nullableText,
+    pending_status: { ...nullableText, default: null },
+    server_status: { ...nullableText, default: null },
+    status_at: { ...nullableText, default: null },
+    approver_token: { ...nullableText, default: null },
+    server_expected: { type: ["object", "null"], additionalProperties: minor, default: null },
+    server_sales_count: { type: ["integer", "null"], default: null }
+  },
+  required: ["id", "register_id", "status", "opened_at_gmt", "counted_float_minor"],
+  indexes: [["register_id", "status"]]
+};
+function registerSessionCollection() {
+  addRxPlugin2(RxDBLocalDocumentsPlugin);
+  return { schema: registerSessionSchema, localDocuments: true };
+}
+var cashMovementSchema = {
+  title: "Cash movements",
+  version: 0,
+  primaryKey: "id",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id,
+    session_id: id,
+    type: { type: "string", enum: ["paid_in", "paid_out", "no_sale", "void"] },
+    amountMinor: minor,
+    reason: text,
+    created_at_gmt: text,
+    created_by: nullableText,
+    voids: nullableText,
+    voided_by: nullableText
+  },
+  required: ["id", "session_id", "type", "amountMinor", "reason", "created_at_gmt"],
+  indexes: [["session_id"]]
+};
+var closureSchema = {
+  title: "Register closures",
+  version: 0,
+  primaryKey: "id",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id,
+    session_id: id,
+    register_id: id,
+    store_key: nullableText,
+    business_day: { type: "string", maxLength: 10 },
+    closed_by: nullableText,
+    corrections_count: { type: "integer" },
+    number: { type: "integer" },
+    opened_at: text,
+    closed_at: text,
+    till_expected: tenders,
+    expected: tenders,
+    counted: tenders,
+    variance: tenders,
+    period_sales_total_minor: minor,
+    period_refunds_total_minor: minor,
+    perpetual_sales_total_minor: minor,
+    perpetual_refunds_total_minor: minor,
+    unsynced_count: { type: "integer" },
+    unsynced_total_minor: minor,
+    software_version: text,
+    breakdowns: { type: "object", additionalProperties: true },
+    order_ids: { type: "array", items: text },
+    movement_ids: { type: "array", items: text },
+    server_closure_id: { ...nullableText, default: null },
+    printed_at: { ...nullableText, default: null },
+    print_count: { type: "integer", default: 0 },
+    number_retried: { type: "boolean", default: false }
+  },
+  required: [
+    "id",
+    "session_id",
+    "register_id",
+    "number",
+    "opened_at",
+    "closed_at",
+    "till_expected",
+    "expected",
+    "counted",
+    "variance",
+    "period_sales_total_minor",
+    "period_refunds_total_minor",
+    "perpetual_sales_total_minor",
+    "perpetual_refunds_total_minor",
+    "unsynced_count",
+    "unsynced_total_minor",
+    "software_version",
+    "breakdowns",
+    "order_ids",
+    "movement_ids",
+    "print_count"
+  ],
+  indexes: [["register_id"], ["session_id"]]
+};
+
+// src/register/register-document.ts
+import { map as map4 } from "rxjs";
+var REGISTER = "register";
+function mintUuid() {
+  const id2 = globalThis.crypto?.randomUUID?.();
+  if (id2) return id2;
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+async function readRegister(host) {
+  return (await host.getLocal(REGISTER))?.toJSON(true).data ?? null;
+}
+async function ensureRegister(host, platform) {
+  const existing = await readRegister(host);
+  if (existing) return existing;
+  const id2 = mintUuid().toLowerCase();
+  const data = {
+    id: id2,
+    name: `Register ${id2.slice(-4).toUpperCase()}`,
+    platform,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    stores: {}
+  };
+  try {
+    await host.insertLocal(REGISTER, data);
+    return data;
+  } catch (error) {
+    const winner = await readRegister(host);
+    if (winner) return winner;
+    throw error;
+  }
+}
+function observeRegister$(host) {
+  return host.getLocal$(REGISTER).pipe(map4((doc) => doc?.toJSON(true).data ?? null));
+}
+async function modifyStore(host, storeKey, modify) {
+  const doc = await host.getLocal(REGISTER);
+  if (!doc) throw new Error("Register is not initialized");
+  await doc.incrementalModify((data) => {
+    const store = modify(data.stores[storeKey]);
+    return store ? { ...data, stores: { ...data.stores, [storeKey]: store } } : data;
+  });
+}
+function getBoundRegisterId(register, storeKey) {
+  return register?.stores?.[storeKey]?.register_id ?? null;
+}
+async function readBoundRegister(host, storeKey) {
+  const register = await readRegister(host);
+  const id2 = getBoundRegisterId(register, storeKey);
+  return id2 ? { id: id2, name: register?.stores[storeKey]?.register_name ?? "" } : null;
+}
+function bindRegister(host, storeKey, register) {
+  return modifyStore(host, storeKey, (store) => ({
+    ...store ?? { sale_counter: 0 },
+    register_id: register.id,
+    register_name: register.name
+  }));
+}
+function unbindRegister(host, storeKey) {
+  return modifyStore(host, storeKey, (store) => store && { ...store, register_id: null, register_name: null });
+}
+async function nextSaleCounter(host, storeKey) {
+  let counter = 0;
+  await modifyStore(host, storeKey, (store) => {
+    counter = (store?.sale_counter ?? 0) + 1;
+    return { ...store ?? {}, sale_counter: counter };
+  });
+  return counter;
+}
+function withRegister(store, registerId, bucket) {
+  const base = store ?? { sale_counter: 0 };
+  return { ...base, registers: { ...base.registers, [registerId]: bucket } };
+}
+async function mintClosureNumber(host, storeKey, registerId, closure) {
+  let number = 0;
+  await modifyStore(host, storeKey, (store) => {
+    const register = store?.registers?.[registerId] ?? {};
+    const reservation = register.closure_reservation;
+    if (closure && reservation?.row.id === closure.id && !!reservation.row.number_retried === !!closure.number_retried) {
+      number = reservation.row.number;
+      return void 0;
+    }
+    if (closure && reservation && reservation.row.id !== closure.id && !reservation.applied) {
+      throw new Error("closure_write_incomplete");
+    }
+    number = (register.last_closure_number ?? 0) + 1;
+    const applied = closure && reservation?.row.id === closure.id && reservation.applied ? reservation.row : null;
+    const sales = closure ? (register.perpetual_sales_total_minor ?? 0) - (applied?.period_sales_total_minor ?? 0) + closure.period_sales_total_minor : 0;
+    const refunds = closure ? (register.perpetual_refunds_total_minor ?? 0) - (applied?.period_refunds_total_minor ?? 0) + closure.period_refunds_total_minor : 0;
+    const next = closure ? {
+      row: { ...closure, number, perpetual_sales_total_minor: sales, perpetual_refunds_total_minor: refunds },
+      applied: !!applied || !!closure.number_retried
+    } : reservation;
+    return withRegister(store, registerId, {
+      ...register,
+      last_closure_number: number,
+      ...next ? { closure_reservation: next } : {},
+      // An applied period follows the closure row it came from.
+      ...applied ? { perpetual_sales_total_minor: sales, perpetual_refunds_total_minor: refunds } : {}
+    });
+  });
+  return number;
+}
+function advancePerpetual(host, storeKey, registerId, period) {
+  return modifyStore(host, storeKey, (store) => {
+    const register = store?.registers?.[registerId] ?? {};
+    const reservation = register.closure_reservation;
+    if (period.closureId && (!reservation || reservation.row.id !== period.closureId || reservation.applied)) {
+      return void 0;
+    }
+    const sales = register.perpetual_sales_total_minor ?? 0;
+    const refunds = register.perpetual_refunds_total_minor ?? 0;
+    return withRegister(store, registerId, {
+      ...register,
+      ...period.closureId && reservation ? { closure_reservation: { ...reservation, applied: true } } : {},
+      perpetual_sales_total_minor: period.closureId && reservation ? Math.max(sales, reservation.row.perpetual_sales_total_minor) : sales + period.salesMinor,
+      perpetual_refunds_total_minor: period.closureId && reservation ? Math.max(refunds, reservation.row.perpetual_refunds_total_minor) : refunds + period.refundsMinor,
+      counters_started_at: register.counters_started_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+}
+function markClosuresSwept(host, storeKey, registerId, closureIds) {
+  return modifyStore(host, storeKey, (store) => {
+    const register = store?.registers?.[registerId] ?? {};
+    const swept = new Set(register.swept_closure_ids);
+    closureIds.forEach((closureId) => swept.add(closureId));
+    return withRegister(store, registerId, { ...register, swept_closure_ids: [...swept] });
+  });
+}
+
+// src/register/facts.ts
+var registerFactsLogger = createLogger("register-session");
+var attempt = () => ({ operationId: mintUuid().replace(/-/g, "") });
+function identity(fact) {
+  switch (fact.kind) {
+    case "session-opened":
+      return { operationId: fact.sessionId?.replace(/-/g, "") ?? "" };
+    case "session-closed":
+      return { operationId: fact.closureId.replace(/-/g, "") };
+    case "movement-recorded":
+    case "movement-voided":
+      return { operationId: fact.movementId.replace(/-/g, "") };
+    case "late-sale":
+      return { operationId: fact.orderId.replace(/-/g, "") };
+    default:
+      return attempt();
+  }
+}
+function recordRegisterFact(fact) {
+  const terminal = identity(fact);
+  const pair = { sessionId: fact.sessionId, registerId: fact.registerId };
+  const emit = (message, type, context = {}, level = "info") => registerFactsLogger[level](message, { actor: fact.actor, terminal, context: { type, ...pair, ...context } });
+  switch (fact.kind) {
+    case "session-opened":
+      return emit("Register session opened", "register.session-opened", { amount: fact.amount, variance: fact.variance });
+    case "counting-started":
+      return emit("Register session counting started", "register.counting-started");
+    case "counting-abandoned":
+      return emit("Register session counting abandoned", "register.counting-abandoned");
+    case "session-closed":
+      return emit("Register session closed", "register.session-closed", {
+        closureId: fact.closureId,
+        number: fact.number,
+        counted: fact.counted,
+        variance: fact.variance
+      });
+    case "movement-recorded":
+      if (fact.movementType === "no_sale")
+        return emit("Register no-sale recorded", "register.no-sale-recorded", { movementId: fact.movementId });
+      return emit("Register cash movement recorded", "register.movement-recorded", {
+        movementId: fact.movementId,
+        movementType: fact.movementType,
+        amount: fact.amount
+      });
+    case "movement-voided":
+      return emit("Register cash movement voided", "register.movement-voided", {
+        movementId: fact.movementId,
+        movementType: fact.movementType,
+        amount: fact.amount,
+        voids: fact.voids
+      });
+    case "approval-granted":
+      return emit("Register session approval granted", "register.approval-granted", { approvedBy: fact.approvedBy });
+    case "approval-refused":
+      return emit("Register session approval refused", "register.approval-refused", {}, "warn");
+    case "variance-over-threshold":
+      return emit(
+        "Register count exceeds variance threshold",
+        "register.variance-over-threshold",
+        { variance: fact.variance, threshold: fact.threshold },
+        "warn"
+      );
+    // These prove dispatch success, not that paper printed or a physical drawer opened.
+    case "x-report-dispatched":
+      return emit("Register X-report print dispatched", "register.x-report-printed");
+    case "drawer-dispatched":
+      return emit("Register drawer kick dispatched", "register.drawer-opened");
+    // The money was taken, so the sale is kept and queued, outside every closure.
+    case "late-sale":
+      return emit("Register late sale kept outside its session", "register.late-sale", { orderId: fact.orderId }, "warn");
+  }
+}
+
+// src/register/session-store.ts
+var RegisterSessionRequiredError = class extends Error {
+  constructor() {
+    super("register_session_not_open");
+    this.name = "RegisterSessionRequiredError";
+  }
+};
+var RegisterSessionClosedError = class extends Error {
+  constructor() {
+    super("register_session_closed");
+    this.name = "RegisterSessionClosedError";
+  }
+};
+var RegisterMovementStrandedError = class extends Error {
+  id;
+  session_id;
+  constructor(movement) {
+    super("Recorded, but the session closed while saving. It may not be on this session's Z. Do not enter it again.");
+    this.name = "RegisterMovementStrandedError";
+    this.id = movement.id;
+    this.session_id = movement.session_id;
+  }
+};
+var TRANSITIONS = {
+  open: ["counting", "closed"],
+  counting: ["open", "closed"],
+  closed: []
+};
+async function readSession(sessions, id2) {
+  const [stored] = await sessions.storageInstance.findDocumentsById([id2], false);
+  return stored;
+}
+async function readClosure(closures, id2) {
+  const [stored] = await closures?.storageInstance.findDocumentsById([id2], false) ?? [];
+  return stored;
+}
+async function requireLiveSession(sessions, id2) {
+  const session = await readSession(sessions, id2);
+  if (!session) throw new RegisterSessionRequiredError();
+  if (session.status === "closed") throw new RegisterSessionClosedError();
+  return session;
+}
+var openSessionSelector = { status: "open" };
+async function requireOpenSession(sessions, registerId, enabled) {
+  if (!enabled) return null;
+  const session = await sessions?.findOne({ selector: { register_id: registerId ?? "", ...openSessionSelector } }).exec();
+  if (!session) throw new RegisterSessionRequiredError();
+  await session.incrementalPatch({ server_expected: null, server_sales_count: null });
+  return session.id;
+}
+async function stampSession(order, sessionId, sessions) {
+  if (order.sessionId !== void 0 && order.sessionId !== sessionId) throw new Error("session_already_stamped");
+  const session = await requireLiveSession(sessions, sessionId);
+  return { ...order, sessionId: session.id };
+}
+var SWEEP_GRACE_MS = 10 * 6e4;
+async function sweepOrphanStamps({ sessions, closures, orders, registerId, register, storeKey, full = false }) {
+  const closed = new Set((await readFresh(sessions, { selector: { register_id: registerId, status: "closed" } })).map(({ id: id2 }) => id2));
+  const swept = new Set((await readRegister(register))?.stores[storeKey]?.registers?.[registerId]?.swept_closure_ids);
+  const unswept = (await readFresh(closures, { selector: { register_id: registerId } })).filter((closure) => closed.has(closure.session_id) && (full || !swept.has(closure.id)));
+  const frozen = new Map(unswept.map((closure) => [closure.session_id, new Set(closure.order_ids)]));
+  const patched = [];
+  if (!frozen.size) return patched;
+  for (const { id: id2, sessionId, cashierRef } of await readFresh(orders, { selector: { sessionId: { $in: [...frozen.keys()] } } })) {
+    if (!sessionId || frozen.get(sessionId)?.has(id2) !== false) continue;
+    let late = false;
+    await (await orders.findOne(id2).exec())?.incrementalModify((doc) => {
+      late = doc.sessionId === sessionId && doc.lateSessionId === void 0;
+      if (!late) return doc;
+      delete doc.sessionId;
+      return { ...doc, lateSessionId: sessionId };
+    });
+    if (!late) continue;
+    patched.push(id2);
+    try {
+      recordRegisterFact({ kind: "late-sale", orderId: id2, sessionId, registerId, actor: { id: cashierRef ?? "", name: "" } });
+    } catch {
+    }
+  }
+  const now = Date.now();
+  const markSwept = unswept.filter((closure) => now - new Date(closure.closed_at).getTime() >= SWEEP_GRACE_MS).map(({ id: id2 }) => id2);
+  if (markSwept.length) await markClosuresSwept(register, storeKey, registerId, markSwept);
+  return patched;
+}
+function businessDayOf(atGmt, timezone) {
+  const at2 = new Date(atGmt.endsWith("Z") ? atGmt : `${atGmt}Z`);
+  const format2 = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone === "device" ? void 0 : timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const part = Object.fromEntries(format2.formatToParts(at2).map(({ type, value }) => [type, value]));
+  return `${part.year}-${part.month}-${part.day}`;
+}
+function openSession(sessions, input) {
+  const { year, month, day } = input.businessDay;
+  return sessions.insert({
+    id: mintUuid(),
+    register_id: input.registerId,
+    store_key: input.storeKey ?? null,
+    status: "open",
+    opened_at_gmt: (/* @__PURE__ */ new Date()).toISOString(),
+    opened_by: input.openedBy,
+    business_day: `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`,
+    expected_float_minor: input.expectedFloatMinor,
+    counted_float_minor: input.countedFloatMinor,
+    opening_variance_minor: input.expectedFloatMinor === null ? null : countVariance(input.countedFloatMinor, input.expectedFloatMinor)
+  });
+}
+async function transition(sessions, id2, status, extra = {}) {
+  const row = await sessions.findOne(id2).exec();
+  if (!row) throw new RegisterSessionRequiredError();
+  if (row.status === "closed" && status === "closed") return row;
+  const at2 = (/* @__PURE__ */ new Date()).toISOString();
+  return row.incrementalModify((doc) => {
+    if (doc.status === "closed" && status === "closed") return doc;
+    if (doc.status === "closed") throw new RegisterSessionClosedError();
+    if (!TRANSITIONS[doc.status].includes(status)) throw new Error(`invalid_session_transition:${doc.status}->${status}`);
+    return {
+      ...doc,
+      ...extra,
+      status,
+      pending_status: status,
+      status_at: at2,
+      ...status === "counting" ? { counting_started_at_gmt: at2 } : {},
+      ...status === "closed" ? { closed_at_gmt: at2 } : {}
+    };
+  });
+}
+var startCounting = (sessions, id2) => transition(sessions, id2, "counting");
+var backToSelling = (sessions, id2) => transition(sessions, id2, "open");
+async function closeSession(sessions, id2, input) {
+  const session = await sessions.findOne(id2).exec();
+  if (!session) throw new RegisterSessionRequiredError();
+  return transition(sessions, id2, "closed", {
+    business_day: session.business_day || businessDayOf(session.opened_at_gmt, input.timezone ?? "device"),
+    counted: input.counted,
+    closed_by: input.closedBy ?? null,
+    ...input.approvedBy ? { approved_by: input.approvedBy } : {},
+    closure_id: id2
+  });
+}
+async function recordMovement(sessions, movements, closures, input) {
+  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,
+    created_by: input.actor,
+    created_at_gmt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  let counted;
+  try {
+    const after = await readSession(sessions, input.sessionId);
+    if (after?.status !== "closed") return row;
+    counted = (await closures.findOne(input.sessionId).exec())?.movement_ids;
+  } catch {
+    return row;
+  }
+  if (!counted) throw new RegisterMovementStrandedError(row);
+  if (counted.includes(row.id)) return row;
+  try {
+    await row.remove();
+  } catch {
+    throw new RegisterMovementStrandedError(row);
+  }
+  throw new RegisterSessionClosedError();
+}
+async function voidMovement(sessions, movements, movementId, actor, closures) {
+  const row = await movements.findOne(movementId).exec();
+  if (!row || row.type === "void") throw new Error("invalid_void_target");
+  await requireLiveSession(sessions, row.session_id);
+  const id2 = mintUuid();
+  const claimed = await row.incrementalModify((doc) => {
+    doc.voided_by ??= id2;
+    return doc;
+  });
+  const reversalId = claimed.voided_by;
+  const existing = await movements.findOne(reversalId).exec();
+  const reversal = existing ?? await movements.incrementalUpsert({
+    id: reversalId,
+    session_id: row.session_id,
+    type: "void",
+    amountMinor: row.amountMinor,
+    reason: row.reason,
+    created_by: actor,
+    created_at_gmt: (/* @__PURE__ */ new Date()).toISOString(),
+    voids: row.id
+  });
+  let counted;
+  try {
+    const after = await readSession(sessions, row.session_id);
+    if (after?.status !== "closed") return reversal;
+    counted = (await readClosure(closures, row.session_id))?.movement_ids;
+  } catch {
+    return reversal;
+  }
+  if (counted?.includes(reversal.id)) return reversal;
+  throw new RegisterMovementStrandedError(reversal);
+}
+async function writeClosure({
+  closures,
+  register,
+  storeKey,
+  session,
+  counted,
+  otherTenders,
+  movements,
+  orders,
+  tillExpected,
+  labels,
+  resolveCashierName,
+  softwareVersion,
+  timezone = "device"
+}) {
+  if (session.status !== "closed" || !session.closed_at_gmt) throw new Error("register_session_not_closed");
+  const existing = await closures.findOne(session.id).exec();
+  if (existing) {
+    await advancePerpetual(register, storeKey, session.register_id, {
+      salesMinor: existing.period_sales_total_minor,
+      refundsMinor: existing.period_refunds_total_minor,
+      closureId: existing.id
+    });
+    return existing;
+  }
+  const bound = orders.filter((order) => order.sessionId === session.id);
+  const rows = bound.flatMap(
+    (order) => order.payments.map((payment) => ({
+      session_id: order.sessionId,
+      kind: payment.method === "cash" ? "cash" : "other",
+      method_id: payment.method,
+      status: "captured",
+      amountMinor: payment.amountMinor
+    }))
+  );
+  const entries = movements.filter((row2) => row2.session_id === session.id);
+  const till_expected = tillExpected ?? deriveExpected({
+    session: { id: session.id, countedFloatMinor: session.counted_float_minor },
+    movements: entries,
+    ledgerRowsBySession: rows
+  });
+  const counts = { cash: counted, ...otherTenders };
+  const sum = (values) => values.reduce((total, value) => total + value, 0);
+  const payment_methods = {};
+  for (const row2 of rows) {
+    const method = row2.kind === "cash" ? "cash" : row2.method_id;
+    payment_methods[method] = { sales_minor: (payment_methods[method]?.sales_minor ?? 0) + row2.amountMinor, refunds_minor: 0 };
+  }
+  const taxRates = /* @__PURE__ */ new Map();
+  for (const order of bound) {
+    const lines = order.lines.map((line) => ({ ...line, taxInclusive: line.taxInclusive ?? order.pricesIncludeTax }));
+    for (const { ratePpm, netMinor, amountMinor } of taxLinesByRate(lines, order.taxMinor)) {
+      const existing2 = taxRates.get(String(ratePpm));
+      taxRates.set(String(ratePpm), {
+        ratePpm,
+        net_minor: (existing2?.net_minor ?? 0) + netMinor,
+        tax_minor: (existing2?.tax_minor ?? 0) + amountMinor
+      });
+    }
+  }
+  const unsynced = bound.filter((order) => order.syncStatus === "pending");
+  const draft = {
+    id: session.id,
+    session_id: session.id,
+    register_id: session.register_id,
+    store_key: session.store_key ?? null,
+    number: 0,
+    opened_at: session.opened_at_gmt,
+    business_day: session.business_day || businessDayOf(session.opened_at_gmt, timezone),
+    closed_by: session.closed_by ?? null,
+    closed_at: session.closed_at_gmt,
+    till_expected,
+    expected: till_expected,
+    counted: counts,
+    variance: Object.fromEntries(
+      Object.entries(counts).map(([method, value]) => [method, countVariance(value, till_expected[method] ?? 0)])
+    ),
+    period_sales_total_minor: sum(rows.map((row2) => row2.amountMinor)),
+    period_refunds_total_minor: 0,
+    perpetual_sales_total_minor: 0,
+    perpetual_refunds_total_minor: 0,
+    unsynced_count: unsynced.length,
+    unsynced_total_minor: sum(unsynced.flatMap((order) => order.payments.map((payment) => payment.amountMinor))),
+    software_version: softwareVersion,
+    printed_at: null,
+    print_count: 0,
+    breakdowns: {
+      ...labels,
+      opened_by: session.opened_by ?? null,
+      approved_by: session.approved_by ?? null,
+      payment_methods,
+      tax_rates: Object.fromEntries(
+        [...taxRates.values()].map(({ ratePpm, net_minor, tax_minor }) => [
+          ratePpm,
+          { name: `Tax ${ratePpm / 1e4}%`, net_minor, tax_minor, gross_minor: net_minor + tax_minor }
+        ])
+      ),
+      opening_float: {
+        expected_minor: session.expected_float_minor ?? null,
+        counted_minor: session.counted_float_minor,
+        variance_minor: session.opening_variance_minor ?? null
+      },
+      movements: entries.map(({ id: id2, type, amountMinor, reason, voids, voided_by, created_at_gmt, created_by }) => ({
+        id: id2,
+        type,
+        amountMinor,
+        reason,
+        voids: voids ?? null,
+        created_at_gmt,
+        created_by: created_by ?? null,
+        voided_by: voided_by ?? null
+      })),
+      transaction_count: bound.length,
+      refund_count: 0,
+      cashiers: [...new Set(bound.map((order) => order.cashierRef ?? "").filter(Boolean))].map((id2) => ({
+        id: id2,
+        name: resolveCashierName?.(id2) || id2
+      }))
+    },
+    order_ids: bound.map((order) => order.id),
+    movement_ids: entries.map((row2) => row2.id)
+  };
+  await mintClosureNumber(register, storeKey, session.register_id, draft);
+  const reserved = (await readRegister(register)).stores[storeKey].registers[session.register_id].closure_reservation.row;
+  let row;
+  try {
+    row = await closures.insert({ ...reserved, order_ids: [...reserved.order_ids], movement_ids: [...reserved.movement_ids] });
+  } catch (error) {
+    const winner = await closures.findOne(reserved.id).exec();
+    if (!winner) throw error;
+    row = winner;
+  }
+  await advancePerpetual(register, storeKey, session.register_id, {
+    salesMinor: row.period_sales_total_minor,
+    refundsMinor: row.period_refunds_total_minor,
+    closureId: row.id
+  });
+  return row;
+}
+
+// src/register/settled-figures.ts
+function deriveSettled(recorded, corrections) {
+  const settled = {
+    ...recorded,
+    expected: { ...recorded.expected },
+    counted: { ...recorded.counted },
+    variance: { ...recorded.variance }
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (const correction of [...corrections].sort(
+    (a, b) => a.created_at.localeCompare(b.created_at) || a.id - b.id
+  )) {
+    if (seen.has(correction.id)) continue;
+    seen.add(correction.id);
+    const f = correction.figures;
+    if (correction.type === "recount" && f.counted) Object.assign(settled.counted, f.counted);
+    const deltas = correction.type === "late_movement" ? { cash: f.cash_delta ?? 0 } : correction.type === "late_sale" ? f.expected_delta ?? {} : {};
+    for (const [tender, delta] of Object.entries(deltas))
+      settled.expected[tender] = (settled.expected[tender] ?? 0) + delta;
+    if (correction.type === "late_sale") {
+      settled.period_sales_total_minor += f.sales_delta ?? 0;
+      settled.perpetual_sales_total_minor += f.sales_delta ?? 0;
+      settled.period_refunds_total_minor += f.refunds_delta ?? 0;
+      settled.perpetual_refunds_total_minor += f.refunds_delta ?? 0;
+    }
+  }
+  if (corrections.length)
+    for (const tender of /* @__PURE__ */ new Set([...Object.keys(settled.expected), ...Object.keys(settled.counted)]))
+      settled.variance[tender] = (settled.counted[tender] ?? 0) - (settled.expected[tender] ?? 0);
+  const touched = /* @__PURE__ */ new Set();
+  for (const field of [
+    "expected",
+    "counted",
+    "variance",
+    "period_sales_total_minor",
+    "period_refunds_total_minor",
+    "perpetual_sales_total_minor",
+    "perpetual_refunds_total_minor"
+  ]) {
+    const value = settled[field];
+    if (typeof value === "number") {
+      if (value !== recorded[field]) touched.add(field);
+    } else
+      for (const [tender, amount] of Object.entries(value))
+        if (amount !== (recorded[field][tender] ?? 0))
+          touched.add(`${field}.${tender}`);
+  }
+  return { settled, touched };
+}
+
+// src/register/money.ts
+function minorToDecimal(minor2, exponent) {
+  const sign = minor2 < 0 ? "-" : "";
+  const abs = Math.abs(minor2);
+  const scale = 10 ** exponent;
+  const whole = Math.trunc(abs / scale);
+  const fraction = abs % scale;
+  return exponent === 0 ? `${sign}${whole}` : `${sign}${whole}.${String(fraction).padStart(exponent, "0")}`;
+}
+
+// src/register/export-csv.ts
+var at = (map6, key) => map6[key];
+function exportCsv(rows, exponent, t, names = {}, storeName = "") {
+  const tenders2 = [
+    ...new Set(
+      rows.flatMap((row) => [
+        ...Object.keys(row.expected),
+        ...Object.keys(row.counted),
+        ...Object.keys(row.variance)
+      ])
+    )
+  ];
+  const cell = (value) => {
+    const text2 = String(value ?? "");
+    return `"${(/^(?:[\t\r\n]|[\s\x00-\x1f\x7f-\x9f]*[=+\-@])/.test(text2) ? "'" + text2 : text2).replace(/"/g, '""')}"`;
+  };
+  const header = ["business_day", "closure", "register", "store", "opened", "closed", "closer"].map(
+    (key) => t(`reports.csv_${key}`)
+  );
+  header.push(
+    ...tenders2.flatMap((method) => [
+      `${t("reports.document.expected")} (${method})`,
+      `${t("register.counted")} (${method})`,
+      `${t("register.variance")} (${method})`
+    ]),
+    t("reports.csv_status")
+  );
+  return [
+    header,
+    ...rows.map((row) => [
+      row.business_day,
+      row.number,
+      row.breakdowns.register_name || names[row.register_id] || row.register_id.slice(0, 8),
+      row.breakdowns.store_name || storeName || row.store_key,
+      row.opened_at,
+      row.closed_at,
+      row.breakdowns.closed_by_name || t("register.unknown_cashier"),
+      ...tenders2.flatMap((method) => {
+        const expected = at(row.expected, method);
+        const counted = at(row.counted, method) ?? (expected === void 0 ? void 0 : 0);
+        const value = at(row.variance, method) ?? (expected === void 0 ? void 0 : (counted ?? 0) - expected);
+        return [
+          expected === void 0 ? "" : minorToDecimal(expected, exponent),
+          counted === void 0 ? "" : minorToDecimal(counted, exponent),
+          value === void 0 ? "" : `${minorToDecimal(Math.abs(value), exponent)} ${t(value < 0 ? "register.short" : value > 0 ? "register.over" : "reports.exact")}`
+        ];
+      }),
+      row.unsynced_count > 0 ? t("register.unsynced") : row.corrections_count ? t("reports.corrected") : ""
+    ])
+  ].map((row) => row.map(cell).join(",")).join("\r\n");
+}
+
+// src/register/document-labels.ts
+var labelKeys = {
+  x_report: "register.x_report",
+  closure: "reports.document.closure",
+  opened: "reports.document.opened",
+  closed: "register.closed",
+  approver: "reports.document.approver",
+  opening_float: "reports.document.opening_float",
+  expected: "reports.document.expected",
+  counted: "register.counted",
+  variance: "register.variance",
+  tenders: "reports.document.tenders",
+  tender: "reports.document.tender",
+  cash_movements: "reports.document.cash_movements",
+  time: "common.time",
+  type: "common.type",
+  amount: "register.amount",
+  reason: "register.reason",
+  sales: "reports.sales",
+  period_sales: "register.period_sales",
+  period_refunds: "register.period_refunds",
+  transactions: "reports.document.transactions",
+  refunds: "common.refunds",
+  payment_method: "reports.document.payment_method",
+  cashiers: "reports.document.cashiers",
+  tax_rates: "common.tax_rates",
+  tax_rate: "reports.document.tax_rate",
+  net: "reports.document.net",
+  tax: "common.tax",
+  gross: "reports.document.gross",
+  perpetual_totals: "reports.document.perpetual_totals",
+  perpetual_sales: "register.perpetual_sales",
+  perpetual_refunds: "register.perpetual_refunds",
+  unsynced_sales: "reports.document.unsynced_sales",
+  short: "reports.document.short",
+  over: "reports.document.over",
+  exact: "reports.exact",
+  voided: "pos_checkout.status_voided",
+  paid_in: "register.paid_in",
+  paid_out: "register.paid_out",
+  no_sale: "register.no_sale",
+  void: "register.void",
+  copy: "reports.document.copy"
+};
+
+// src/register/closure-rows.ts
+var DEFAULT_HISTORY_DAYS = 92;
+function daysBefore(day, days) {
+  const at2 = /* @__PURE__ */ new Date(`${day}T00:00:00Z`);
+  at2.setUTCDate(at2.getUTCDate() - days);
+  return at2.toISOString().slice(0, 10);
+}
+function clampClosureScope(scope, today, historyDays = DEFAULT_HISTORY_DAYS) {
+  const min = daysBefore(today, historyDays);
+  const clamp = (day) => day < min ? min : day > today ? today : day;
+  return { ...scope, from: clamp(scope.from), to: clamp(scope.to) };
+}
+function selectClosureRows(rows, scope, timezone) {
+  return rows.map((row) => ({
+    ...row,
+    business_day: row.business_day || businessDayOf(row.opened_at, timezone)
+  })).filter(
+    (row) => row.business_day >= scope.from && row.business_day <= scope.to && (!scope.registerId || row.register_id === scope.registerId) && (row.store_key ?? null) === (scope.storeKey ?? null) && (scope.cashier === void 0 || row.closed_by === scope.cashier)
+  ).sort((a, b) => b.business_day.localeCompare(a.business_day) || b.closed_at.localeCompare(a.closed_at));
+}
+
+// src/register/closure-document.ts
+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;
+  const group = (key, pairs) => {
+    const source = breakdowns[key];
+    return source && Object.fromEntries(
+      Object.entries(source).map(([id2, entry]) => [
+        id2,
+        { ...entry, ...Object.fromEntries(pairs.map(([from, to]) => [to, dec(entry[from])])) }
+      ])
+    );
+  };
+  const openingFloat = breakdowns.opening_float;
+  return {
+    ...breakdowns,
+    ...breakdowns.payment_methods ? { payment_methods: group("payment_methods", [["sales_minor", "sales"], ["refunds_minor", "refunds"]]) } : {},
+    ...breakdowns.tax_rates ? { tax_rates: group("tax_rates", [["net_minor", "net"], ["tax_minor", "tax"], ["gross_minor", "gross"]]) } : {},
+    ...openingFloat ? {
+      opening_float: {
+        ...openingFloat,
+        expected: dec(openingFloat.expected_minor),
+        counted: dec(openingFloat.counted_minor),
+        variance: dec(openingFloat.variance_minor)
+      }
+    } : {},
+    ...breakdowns.movements ? { movements: breakdowns.movements.map((m) => ({ ...m, amount: dec(m.amountMinor) })) } : {}
+  };
+}
+function formatClosureDate(value, context) {
+  const date = value ? new Date(/[Zz]|[+-]\d\d:\d\d$/.test(value) ? value : `${value.replace(" ", "T")}Z`) : null;
+  const timeZone = context.timezone === "device" ? void 0 : context.timezone;
+  const display = (settings) => date ? new Intl.DateTimeFormat(context.locale, { timeZone, ...settings, hour12: false }).format(date) : "";
+  const result = {
+    datetime: display({ dateStyle: "medium", timeStyle: "short" }),
+    date: display({ dateStyle: "medium" }),
+    time: display({ timeStyle: "short" })
+  };
+  for (const style of ["short", "long", "full"]) {
+    result[`datetime_${style}`] = display({ dateStyle: style, timeStyle: style === "short" ? "short" : style });
+    result[`date_${style}`] = display({ dateStyle: style });
+  }
+  const parts = date ? Object.fromEntries(
+    new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(date).map(({ type, value: v }) => [type, v])
+  ) : {};
+  result.date_ymd = date ? `${parts.year}-${parts.month}-${parts.day}` : "";
+  result.date_dmy = date ? `${parts.day}/${parts.month}/${parts.year}` : "";
+  result.date_mdy = date ? `${parts.month}/${parts.day}/${parts.year}` : "";
+  result.day = date ? parts.day : "";
+  result.month = date ? parts.month : "";
+  result.year = date ? parts.year : "";
+  for (const style of ["short", "long"]) {
+    result[`weekday_${style}`] = display({ weekday: style });
+    result[`month_${style}`] = display({ month: style });
+  }
+  return result;
+}
+function envelope(row, context, xreport = false) {
+  const money = (values, fields) => Object.assign(
+    {},
+    values,
+    Object.fromEntries(fields.map((key) => [`${key}_display`, context.formatMoney(String(values[key] ?? ""))]))
+  );
+  const breakdowns = row.breakdowns ?? {};
+  const labels = {
+    opened_by_name: "",
+    closed_by_name: "",
+    approved_by_name: "",
+    ...Object.fromEntries(Object.entries(breakdowns).filter(([key]) => key.endsWith("_name"))),
+    ...breakdowns.labels
+  };
+  const rows = (key, fields) => Object.entries(breakdowns[key] ?? {}).map(
+    ([entryKey, value]) => money({ ...value, name: value.name ?? value.method ?? value.rate ?? entryKey }, fields)
+  );
+  const methods = breakdowns.payment_methods ?? {};
+  const counted = row.counted ?? {};
+  const expected = row.expected ?? {};
+  const variances = row.variance ?? {};
+  const tenders2 = [.../* @__PURE__ */ new Set([...Object.keys(counted), ...Object.keys(expected)])].map((name) => {
+    const variance = variances[name] ?? "";
+    const method = Object.values(methods).find((m) => m.method === name) ?? methods[name];
+    return money(
+      {
+        name,
+        label: method?.name || name.charAt(0).toUpperCase() + name.slice(1),
+        expected: expected[name] ?? "",
+        counted: counted[name] ?? "",
+        variance,
+        has_variance: Number(variance || 0) !== 0,
+        variance_label: variance === "" ? "" : context.i18n[Number(variance) > 0 ? "over" : Number(variance) < 0 ? "short" : "exact"],
+        variance_absolute_display: context.formatMoney(variance.replace("-", ""))
+      },
+      ["expected", "counted", "variance"]
+    );
+  });
+  return {
+    closure: {
+      has_sales: row.period_sales_total != null || row.period_refunds_total != null || Number(breakdowns.transaction_count) > 0,
+      has_perpetual: row.perpetual_sales_total != null || row.perpetual_refunds_total != null,
+      ...Object.fromEntries(
+        ["payment_methods", "tax_rates", "movements"].map((key) => [`has_${key}`, Object.keys(breakdowns[key] ?? {}).length > 0])
+      ),
+      ...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,
+      closed_by: row.closed_by ?? null,
+      approved_by: breakdowns.approved_by ?? null,
+      closed_at_gmt: row.closed_at,
+      opened_at: formatClosureDate(row.opened_at, context),
+      closed_at: formatClosureDate(row.closed_at, context),
+      tenders: tenders2,
+      breakdowns: {
+        ...breakdowns,
+        labels,
+        payment_methods: rows("payment_methods", ["sales", "refunds"]),
+        tax_rates: rows("tax_rates", ["net", "tax", "gross"]),
+        opening_float: money(breakdowns.opening_float ?? {}, ["expected", "counted", "variance"]),
+        movements: (breakdowns.movements ?? []).map((m) => ({
+          ...money(m, ["amount"]),
+          created_at: formatClosureDate(m.created_at_gmt ?? m.created_at, context),
+          type_label: context.i18n[String(m.type)] ?? m.type,
+          voided: !!m.voided_by
+        })),
+        cashiers: (breakdowns.cashiers ?? []).map((c) => typeof c === "string" ? { id: c, name: c } : c)
+      }
+    },
+    store: context.store,
+    register: { id: row.register_id, name: labels.register_name ?? "" },
+    software: { name: "WCPOS", plugin_version: row.software_version ?? "" },
+    order: { currency: context.currency, printed: formatClosureDate(context.printedAt, context) },
+    fiscal: {
+      immutable_id: "",
+      hash: "",
+      qr_payload: "",
+      tax_agency_code: "",
+      signature_excerpt: "",
+      document_label: "",
+      sequence: null,
+      signed_at: null,
+      extra_fields: [],
+      document_type: xreport ? "xreport" : "closure",
+      receipt_number: xreport ? "" : String(row.number),
+      is_sale_document: false,
+      is_refund_document: false,
+      is_closure_document: true,
+      is_x_report: xreport,
+      is_reprint: !xreport && !!row.print_count,
+      reprint_count: xreport ? 0 : row.print_count ?? 0
+    },
+    i18n: context.i18n
+  };
+}
+function buildClosureDocument(row, context) {
+  const { exponent } = context;
+  const dec = (m) => minorToDecimal(m, exponent);
+  const {
+    store_key,
+    till_expected,
+    expected,
+    counted,
+    variance,
+    period_sales_total_minor,
+    period_refunds_total_minor,
+    perpetual_sales_total_minor,
+    perpetual_refunds_total_minor,
+    unsynced_total_minor,
+    ...rest
+  } = row;
+  return envelope(
+    {
+      ...rest,
+      breakdowns: decimalizeBreakdowns(rest.breakdowns, exponent),
+      store_id: store_key,
+      till_expected: decimalMap(till_expected, exponent),
+      expected: decimalMap(expected, exponent),
+      counted: decimalMap(counted, exponent),
+      variance: decimalMap(variance, exponent),
+      period_sales_total: dec(period_sales_total_minor),
+      period_refunds_total: dec(period_refunds_total_minor),
+      perpetual_sales_total: dec(perpetual_sales_total_minor),
+      perpetual_refunds_total: dec(perpetual_refunds_total_minor),
+      unsynced_total: dec(unsynced_total_minor)
+    },
+    context
+  );
+}
+function buildXReportDocument(session, context) {
+  const { exponent } = context;
+  const dec = (m) => m == null ? void 0 : minorToDecimal(m, exponent);
+  const expectedMinor = context.expected ?? session.server_expected ?? {};
+  const countedMinor = session.counted ?? {};
+  const varianceMinor = Object.fromEntries(
+    Object.entries(countedMinor).map(([key, value]) => [key, value - (expectedMinor[key] ?? 0)])
+  );
+  return envelope(
+    {
+      id: session.id,
+      register_id: session.register_id,
+      store_id: session.store_key,
+      opened_at: session.opened_at_gmt,
+      expected: decimalMap(expectedMinor, exponent),
+      counted: decimalMap(countedMinor, exponent),
+      variance: decimalMap(varianceMinor, exponent),
+      breakdowns: {
+        ...context.breakdowns,
+        opening_float: {
+          expected: dec(session.expected_float_minor),
+          counted: dec(session.counted_float_minor),
+          variance: dec(session.opening_variance_minor)
+        }
+      }
+    },
+    context,
+    true
+  );
+}
+
+// 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";
+var RegisterTenderInProgressError = class extends Error {
+  constructor() {
+    super("Finish or cancel the sale in progress first.");
+    this.name = "RegisterTenderInProgressError";
+  }
+};
+var RegisterSessionAlreadyOpenError = class extends Error {
+  constructor() {
+    super("This register already has an open session.");
+    this.name = "RegisterSessionAlreadyOpenError";
+  }
+};
+var RegisterCloseIncompleteError = class extends Error {
+  constructor() {
+    super("Finish closing the previous session first.");
+    this.name = "RegisterCloseIncompleteError";
+  }
+};
+var RegisterApprovalRequiredError = class extends Error {
+  constructor() {
+    super("Manager approval needed. Ask a manager to approve, or count again.");
+    this.name = "RegisterApprovalRequiredError";
+  }
+};
+var openingByRegister = /* @__PURE__ */ new Map();
+var closingByRegister = /* @__PURE__ */ new Map();
+var closingListeners = /* @__PURE__ */ new Set();
+var notifyClosing = () => closingListeners.forEach((listener) => listener());
+var subscribeClosing = (listener) => {
+  closingListeners.add(listener);
+  return () => {
+    closingListeners.delete(listener);
+  };
+};
+var closedFacts = /* @__PURE__ */ new Set();
+var reservationOf = (register, storeKey, registerId) => register?.stores[storeKey]?.registers?.[registerId]?.closure_reservation;
+var unwritten = (row, closureRows) => row.status === "closed" && row.closure_id === row.id && !closureRows.some((closure) => closure.id === row.id);
+function currentSession(rows, closureRows, reservation) {
+  return (reservation && !reservation.applied ? rows.find((row) => row.id === reservation.row.session_id) : void 0) ?? rows.find((row) => row.status !== "closed") ?? rows.find((row) => unwritten(row, closureRows)) ?? null;
+}
+function ledgerRows(orders) {
+  return orders.flatMap((order) => order.payments.map((payment) => ({
+    session_id: order.sessionId,
+    kind: payment.method === "cash" ? "cash" : "other",
+    method_id: payment.method,
+    status: "captured",
+    amountMinor: payment.amountMinor
+  })));
+}
+function useRegisterSession(options) {
+  const { sessions, movements, closures, orders, register, storeKey, registerId, enabled, actor, timezone, tenderInProgress, expectedCloseTime, labels } = options;
+  const source = useMemo3(() => {
+    if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register) return null;
+    return combineLatest([
+      watchFresh(sessions, { selector: { register_id: registerId } }),
+      watchFresh(closures, { selector: { register_id: registerId } }),
+      observeRegister$(register).pipe(map5((document) => reservationOf(document, storeKey, registerId)))
+    ]).pipe(switchMap(([rows, closureRows, reservation]) => {
+      const current2 = currentSession(rows, closureRows, reservation);
+      if (!current2) return of({ rows, closureRows, reservation, entries: [], sales: [] });
+      return combineLatest([
+        watchFresh(movements, { selector: { session_id: current2.id } }),
+        watchFresh(orders, { selector: { sessionId: current2.id } })
+      ]).pipe(map5(([entries2, sales2]) => ({ rows, closureRows, reservation, entries: entries2, sales: sales2 })));
+    }));
+  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId]);
+  const tender = useRef2(tenderInProgress);
+  tender.current = tenderInProgress;
+  const closing = useSyncExternalStore(subscribeClosing, () => closingByRegister.has(registerId ?? ""));
+  const [observed, setObserved] = useState2(null);
+  useEffect2(() => {
+    if (!source) return;
+    const subscription = source.subscribe((snapshot) => setObserved({ source, snapshot }));
+    return () => subscription.unsubscribe();
+  }, [source]);
+  const [, setMinute] = useState2(0);
+  useEffect2(() => {
+    if (!enabled || !expectedCloseTime) return;
+    const timer = setInterval(() => setMinute((value) => value + 1), 6e4);
+    return () => clearInterval(timer);
+  }, [enabled, expectedCloseTime]);
+  const data = source && observed?.source === source ? observed.snapshot : null;
+  const sweeper = useRef2({});
+  sweeper.current.target = enabled && sessions && closures && orders && registerId && register ? { sessions, closures, orders, registerId, register, storeKey } : void 0;
+  const sweep = (full = false) => {
+    const state = sweeper.current;
+    if (state.running) {
+      state.queuedFull = state.queuedFull || full;
+      return state.queued ??= state.running.then(() => {
+        const runFull = !!state.queuedFull;
+        state.queued = void 0;
+        state.queuedFull = void 0;
+        return sweep(runFull);
+      });
+    }
+    const target = state.target;
+    if (!target) return Promise.resolve();
+    const run = sweepOrphanStamps({ ...target, full }).then(() => void 0, (error) => {
+      try {
+        registerFactsLogger.error("Register orphan-stamp sweep failed", { context: { type: "register.sweep-failed", registerId: target.registerId, error: String(error) } });
+      } catch {
+      }
+    }).finally(() => {
+      state.running = void 0;
+    });
+    return state.running = run;
+  };
+  const seen = useRef2(null);
+  useEffect2(() => {
+    if (!data) return;
+    const ids = data.closureRows.map((row) => row.id);
+    if (seen.current?.source !== source) {
+      seen.current = { source, ids: new Set(ids) };
+      void sweep(true);
+    } else if (ids.some((id2) => !seen.current.ids.has(id2))) {
+      ids.forEach((id2) => seen.current.ids.add(id2));
+      void sweep();
+    }
+  }, [data, source]);
+  const session = data ? currentSession(data.rows, data.closureRows, data.reservation) : null;
+  const entries = data?.entries ?? [];
+  const sales = data?.sales ?? [];
+  const expected = session ? deriveExpected({ session: { id: session.id, countedFloatMinor: session.counted_float_minor }, movements: entries, ledgerRowsBySession: ledgerRows(sales) }) : {};
+  const now = /* @__PURE__ */ new Date();
+  const [hour, minute] = String(expectedCloseTime ?? "").split(":").map(Number);
+  const overdue = session?.status === "open" && !!expectedCloseTime && now.getTime() > new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute).getTime();
+  const requireOpen = () => requireOpenSession(sessions ?? void 0, registerId, enabled);
+  const requireSaleSession = async () => {
+    const id2 = await requireOpen();
+    return id2 === null ? null : { id: id2, sessions };
+  };
+  const live = () => {
+    if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register) throw new RegisterSessionRequiredError();
+    return { sessions, movements, closures, orders, registerId, register };
+  };
+  const current = () => {
+    if (!session) throw new RegisterSessionRequiredError();
+    return session;
+  };
+  const refuseDuringTender = () => {
+    if (tender.current) throw new RegisterTenderInProgressError();
+  };
+  const nameOf = (id2) => !id2 ? "" : id2 === actor.id ? actor.name : labels?.resolveCashierName?.(id2) ?? "";
+  return {
+    session,
+    movements: entries,
+    expected,
+    salesCount: sales.length,
+    overdue,
+    /** A `closeSession` for this register is in flight, in any hook instance: the session can already be stored `closed` while its closure isn't written yet. */
+    closing,
+    lastClosure: [...data?.closureRows ?? []].sort((a, b) => b.closed_at.localeCompare(a.closed_at))[0] ?? null,
+    lastClosed: (data?.rows ?? []).filter((row) => row.status === "closed").sort((a, b) => (b.closed_at_gmt ?? "").localeCompare(a.closed_at_gmt ?? ""))[0] ?? null,
+    varianceThreshold: options.varianceThreshold,
+    enabled,
+    blind: options.blind ?? false,
+    /** Pass straight to useSale's `session` option: `complete()` then stamps through `stampSession`. */
+    saleSession: session && sessions && session.status !== "closed" ? { id: session.id, sessions } : void 0,
+    /** The open session's id, `null` when sessions are off, else `RegisterSessionRequiredError`. Call it when tender starts and before a card terminal captures. */
+    requireOpen,
+    /** `requireOpen()`, returning `{ id, sessions }`: pass it to useSale's `startTender`, which pins it (the rendered `saleSession` can lag). */
+    requireSaleSession,
+    actions: {
+      /**
+       * Refuses with `RegisterSessionAlreadyOpenError` while the register has a live session or
+       * another open is running (in any hook instance), and with `RegisterCloseIncompleteError`
+       * while an earlier close hasn't finished: a new session would lock the till behind it.
+       */
+      openSession: async (input) => {
+        const key = registerId ?? "";
+        if (openingByRegister.has(key)) throw new RegisterSessionAlreadyOpenError();
+        const run = (async () => {
+          const { sessions: sessions2, closures: closures2, registerId: registerId2, register: register2 } = live();
+          const rows = await readFresh(sessions2, { selector: { register_id: registerId2 } });
+          if (rows.some((row2) => row2.status !== "closed")) throw new RegisterSessionAlreadyOpenError();
+          const closureRows = await readFresh(closures2, { selector: { register_id: registerId2 } });
+          const reservation = reservationOf(await readRegister(register2), storeKey, registerId2);
+          if (reservation && !reservation.applied || rows.some((row2) => unwritten(row2, closureRows))) {
+            throw new RegisterCloseIncompleteError();
+          }
+          const [year, month, day] = businessDayOf((/* @__PURE__ */ new Date()).toISOString(), timezone).split("-").map(Number);
+          const row = await openSession(sessions2, {
+            ...input,
+            registerId: registerId2,
+            openedBy: actor.id,
+            businessDay: { year, month, day },
+            storeKey: options.storeKey
+          });
+          recordRegisterFact({
+            kind: "session-opened",
+            actor,
+            sessionId: row.id,
+            registerId: row.register_id,
+            amount: row.counted_float_minor,
+            variance: row.opening_variance_minor
+          });
+          return row;
+        })();
+        openingByRegister.set(key, run);
+        try {
+          return await run;
+        } finally {
+          openingByRegister.delete(key);
+        }
+      },
+      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;
+      },
+      backToSelling: async () => {
+        const row = await backToSelling(live().sessions, current().id);
+        recordRegisterFact({ kind: "counting-abandoned", actor, sessionId: row.id, registerId: row.register_id });
+        return row;
+      },
+      /**
+       * `counted` maps each tender to its counted minor units. An interrupted close resumes with
+       * the count persisted on the session, not the one passed to the retry (WCPOS uses the retry's).
+       * Over `varianceThreshold` (`closeNeedsApproval`, as `RegisterCount`), a close without
+       * `approvedBy` throws `RegisterApprovalRequiredError` before any write, blind or not; a
+       * resumed close (the stored session already closed) isn't gated again. `approvedBy` reaches the Z
+       * (`breakdowns.approved_by`), and `approvedByName` its `approved_by_name`.
+       * One close per register runs at a time, in any hook instance: a call while one is in flight joins
+       * it, getting its closure or error, and its own `counted`, `approvedBy` and `approvedByName` are ignored.
+       */
+      closeSession: async (input) => {
+        refuseDuringTender();
+        const key = registerId ?? "";
+        if (closingByRegister.has(key)) return closingByRegister.get(key);
+        const run = (async () => {
+          const { sessions: sessions2, movements: movements2, closures: closures2, orders: orders2, register: register2 } = live();
+          const open = current();
+          const stored = await readSession(sessions2, open.id);
+          if (!stored) throw new RegisterSessionRequiredError();
+          if (stored.status !== "closed" && !input.approvedBy) {
+            const fresh = deriveExpected({
+              session: { id: stored.id, countedFloatMinor: stored.counted_float_minor },
+              movements: await readFresh(movements2, { selector: { session_id: stored.id } }),
+              ledgerRowsBySession: ledgerRows(await readFresh(orders2, { selector: { sessionId: stored.id } }))
+            });
+            if (closeNeedsApproval(input.counted.cash ?? 0, fresh.cash ?? 0, options.varianceThreshold)) throw new RegisterApprovalRequiredError();
+          }
+          const closed = await closeSession(sessions2, open.id, { counted: input.counted, closedBy: actor.id, approvedBy: input.approvedBy, timezone });
+          const approvedByName = input.approvedBy && closed.approved_by === input.approvedBy && input.approvedByName || nameOf(closed.approved_by);
+          const { cash = 0, ...otherTenders } = closed.counted ?? input.counted;
+          const closure = await writeClosure({
+            closures: closures2,
+            register: register2,
+            storeKey,
+            session: closed,
+            counted: cash,
+            otherTenders,
+            timezone,
+            softwareVersion: options.softwareVersion,
+            movements: await readFresh(movements2, { selector: { session_id: closed.id } }),
+            orders: await readFresh(orders2, { selector: { sessionId: closed.id } }),
+            resolveCashierName: labels?.resolveCashierName,
+            labels: {
+              register_name: labels?.registerName ?? "",
+              closed_by_name: nameOf(closed.closed_by),
+              opened_by_name: nameOf(closed.opened_by),
+              approved_by_name: approvedByName
+            }
+          });
+          await sweep();
+          if (!closedFacts.has(closure.id)) {
+            closedFacts.add(closure.id);
+            if (closed.approved_by) {
+              recordRegisterFact({ kind: "approval-granted", actor, sessionId: closed.id, registerId: closed.register_id, approvedBy: closed.approved_by });
+            }
+            recordRegisterFact({
+              kind: "session-closed",
+              actor,
+              sessionId: closed.id,
+              registerId: closed.register_id,
+              closureId: closure.id,
+              number: closure.number,
+              counted: closure.counted,
+              variance: closure.variance
+            });
+          }
+          return closure;
+        })();
+        closingByRegister.set(key, run);
+        notifyClosing();
+        try {
+          return await run;
+        } finally {
+          closingByRegister.delete(key);
+          notifyClosing();
+        }
+      },
+      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;
+      },
+      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;
+      }
+    }
+  };
+}
+
+// src/sale/cart.ts
+import { resolvePrice as resolvePrice2 } from "@tallyui/core";
+var CartError = class extends Error {
+};
+function addEntryToCart(builder, entry, traits, currency) {
+  const { product, variant } = entry;
+  const existing = builder.getSnapshot().lineItems.find((line) => line.variantId === variant.id);
+  if (existing) {
+    builder.updateQuantity(existing.id, existing.quantity + 1);
+    return existing.id;
+  }
+  const name = traits.getName(product) + (traits.getVariantCount(product) > 1 ? ` \xB7 ${variant.title}` : "");
+  const unitPrice = resolvePrice2(variant.prices, currency)?.current;
+  if (!unitPrice) throw new CartError(`No ${currency} price for ${name}`);
+  return builder.addLine({
+    productId: traits.getId(product),
+    variantId: variant.id,
+    name,
+    sku: variant.sku ?? "",
+    imageUrl: traits.getImageUrl?.(product),
+    unitPrice
+  });
+}
+
+// src/sale/use-sale.ts
+var saleLogger = createLogger("sale");
+var DISCOUNTS_UNSUPPORTED = "finalize: discounts are not supported by the server yet (order.create v2)";
+var SALE_SAVING = "This sale is being saved. Retry to finish it.";
+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 [stage, setStage] = useState3({ kind: "cart" });
+  const [error, setError] = useState3(null);
+  const pending = useRef3(null);
+  const [saving, setSaving] = useState3(false);
+  const tenderSession = useRef3(null);
+  const confirmed = useRef3(null);
+  const [canContinue, setCanContinue] = useState3(false);
+  const attempts = useRef3(0);
+  const hungSaveTimer = useRef3(null);
+  const checking = useRef3(null);
+  function clearHungSaveTimer() {
+    if (hungSaveTimer.current !== null) {
+      clearInterval(hungSaveTimer.current);
+      hungSaveTimer.current = null;
+    }
+  }
+  function confirm(completion) {
+    confirmed.current = completion;
+    setCanContinue(!!completion);
+    clearHungSaveTimer();
+  }
+  const inFlight = useRef3(null);
+  const stageNow = useRef3(stage);
+  stageNow.current = stage;
+  function locked() {
+    const active = !!(inFlight.current || pending.current);
+    if (active) setError(SALE_SAVING);
+    return active;
+  }
+  useEffect3(() => {
+    const subscription = builder.order$.subscribe(setOrder);
+    return () => subscription.unsubscribe();
+  }, [builder]);
+  const idle2 = stage.kind === "cart" && !order.lineItems.length;
+  useEffect3(() => {
+    if (idle2 && (madeWith.current.taxContext !== taxContext || madeWith.current.currency !== settings.currency)) result.newSale();
+  });
+  useEffect3(() => () => {
+    clearHungSaveTimer();
+    if (pending.current || inFlight.current) {
+      saleLogger.error(
+        "useSale unmounted with a save pending or in flight",
+        { orderId: pending.current?.posOrder.id, stage: stageNow.current.kind }
+      );
+    }
+  }, []);
+  function setTender(tender) {
+    if (locked()) return;
+    const previous = builder.getSnapshot().payments[0];
+    if (previous) builder.removePayment(previous.id);
+    if (tender) builder.addPayment(tender);
+    setError(null);
+  }
+  function checkStored(completion) {
+    const attempt2 = attempts.current;
+    const isStored = opts.isStored;
+    if (!isStored) return;
+    checking.current = completion;
+    void Promise.resolve(completion.posOrder).then(isStored).catch(() => false).then((stored) => {
+      if (stored === true && attempts.current === attempt2 && pending.current === completion) confirm(completion);
+    }).finally(() => {
+      if (checking.current === completion) checking.current = null;
+    });
+  }
+  async function deliver(completion) {
+    clearHungSaveTimer();
+    const timer = opts.isStored ? setInterval(() => {
+      if (checking.current === completion) return;
+      if (pending.current === completion && inFlight.current && confirmed.current !== completion) checkStored(completion);
+      else if (hungSaveTimer.current === timer) clearHungSaveTimer();
+    }, opts.hungSaveCheckMs ?? HUNG_SAVE_CHECK_MS) : null;
+    hungSaveTimer.current = timer;
+    try {
+      await opts.onSaleCompleted?.(completion.posOrder);
+    } catch (error2) {
+      if (hungSaveTimer.current === timer) clearHungSaveTimer();
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      if (confirmed.current !== completion) {
+        saleLogger.error("onSaleCompleted failed", { orderId: completion.posOrder.id, error: message });
+      }
+      if (pending.current === completion) {
+        setError(`The sale could not be saved: ${message}`);
+        checkStored(completion);
+      }
+      return;
+    }
+    if (hungSaveTimer.current === timer) clearHungSaveTimer();
+    if (pending.current !== completion) return;
+    pending.current = null;
+    confirm(null);
+    setSaving(false);
+    setError(null);
+    stageNow.current = { kind: "receipt", order: completion.order, posOrder: completion.posOrder };
+    setStage(stageNow.current);
+  }
+  function once(attempt2) {
+    if (!inFlight.current && stageNow.current.kind !== "receipt") {
+      const mine = attempt2().finally(() => {
+        if (inFlight.current === mine) inFlight.current = null;
+      });
+      inFlight.current = mine;
+    }
+    return inFlight.current ?? Promise.resolve();
+  }
+  const result = {
+    order,
+    stage,
+    error,
+    idle: idle2,
+    /** A completion is pending (see `complete()`): the sale is locked, and the UI offers Retry. */
+    saving,
+    /** The failed save's order is confirmed stored (see `isStored`): the UI also offers Continue (`continueSale()`). */
+    canContinue,
+    add(entry, traits) {
+      if (locked()) return;
+      try {
+        addEntryToCart(builder, entry, traits, madeWith.current.currency);
+        setError(null);
+      } catch (error2) {
+        if (!(error2 instanceof CartError)) throw error2;
+        setError(error2.message);
+      }
+    },
+    setQuantity(lineId, quantity) {
+      if (!locked()) builder.updateQuantity(lineId, quantity);
+    },
+    remove(lineId) {
+      if (!locked()) builder.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 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);
+      else builder.applyLineDiscount(lineId, discount);
+      const added = applied(builder.getSnapshot()).find((entry) => !before.has(entry.id));
+      if (added?.type === "fixed" && added.amountMinor < added.value) {
+        builder.removeDiscount(added.id);
+        return `The discount is more than the ${lineId === null ? "order" : "line"}`;
+      }
+      return null;
+    },
+    removeDiscount(id2) {
+      if (!locked()) builder.removeDiscount(id2);
+    },
+    /**
+     * Pins `options.session` for this tender when given, else the rendered `session` option. Pass the
+     * session `useRegisterSession`'s `requireSaleSession()` returned: the rendered one can lag a session
+     * opened just before (#170 race). A repeat call mid-tender keeps the first pin.
+     */
+    startTender(method, options) {
+      if (locked()) return;
+      const current = builder.getSnapshot();
+      if (!current.lineItems.length) return;
+      tenderSession.current ??= { session: options?.session ?? opts.session };
+      setTender(method === "external" ? { method, amountMinor: current.totalMinor } : null);
+      setStage({ kind: "tender", method });
+    },
+    setTender,
+    cancelTender() {
+      if (locked()) return;
+      setTender(null);
+      tenderSession.current = null;
+      setStage({ kind: "cart" });
+    },
+    /**
+     * Finalizes the tender, stamps the session (see `session`), hands the order to `onSaleCompleted`,
+     * then shows the receipt. `saving` turns true and the sale locks (every change sets SALE_SAVING)
+     * from this call's entry, not only once the order is built; a refused finalize unlocks it again,
+     * with the refusal's error. Idempotent for one tender attempt (DECISIONS, ADR-052): once the order
+     * is built, that order is the sale, kept as the pending completion, because `onSaleCompleted` may
+     * already have stored it before failing. If `onSaleCompleted` throws, the error is set and the tender stays;
+     * calling `complete()` again reuses the pending completion exactly (the same `id`, `commandId`
+     * 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.
+     */
+    complete: () => once(async () => {
+      attempts.current++;
+      confirm(null);
+      if (pending.current) return deliver(pending.current);
+      setSaving(true);
+      const current = builder.getSnapshot();
+      let posOrder;
+      try {
+        posOrder = finalizeOrder(current, { registerId: opts.registerId, cashierRef: opts.cashierRef, capabilities: opts.capabilities });
+      } catch (error2) {
+        setSaving(false);
+        setError(error2.message);
+        return;
+      }
+      const session = tenderSession.current?.session ?? opts.session;
+      if (tenderSession.current && !tenderSession.current.session && session) {
+        try {
+          saleLogger.warn(
+            "the tender started before its session rendered; pass the confirmed session to startTender",
+            { orderId: posOrder.id, sessionId: session.id }
+          );
+        } catch {
+        }
+      }
+      if (session) {
+        try {
+          posOrder = await stampSession(posOrder, session.id, session.sessions);
+        } catch {
+          const { sessionId: _unstamped, ...unstamped } = posOrder;
+          posOrder = { ...unstamped, lateSessionId: session.id };
+          try {
+            recordRegisterFact({
+              kind: "late-sale",
+              orderId: posOrder.id,
+              sessionId: session.id,
+              registerId: opts.registerId,
+              actor: { id: opts.cashierRef, name: "" }
+            });
+          } catch {
+          }
+        }
+      }
+      pending.current = { order: current, posOrder };
+      return deliver(pending.current);
+    }),
+    /**
+     * Starts a new, empty sale. Refused with SALE_SAVING, changing nothing, while a save is still
+     * building or stamping (nothing yet to ask `isStored` about), and while a pending completion
+     * exists and isn't confirmed stored — the ways out are Retry (`complete()`) or Continue, once
+     * `canContinue` (the Front desk, 2026-09-27; #149 review). So an app that doesn't pass `isStored`
+     * gets Retry only after a failed save. A refusal while a save is still delivering its order asks
+     * `isStored` afresh, so a hung save whose order is stored can still offer Continue. Past those, it
+     * abandons a confirmed pending completion (never handed to `onSaleCompleted` again: it's stored; a
+     * save still in flight carries on in the background, a throw logged at error) and starts the new
+     * sale outright — from the receipt, or an idle cart, there's nothing pending to abandon. Abandoning
+     * clears the screen, never the record (the Front desk, 2026-09-25). `newSale()` never deletes,
+     * 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);
+    },
+    /**
+     * Continue after a failed save whose order is confirmed stored (`canContinue`): exactly `newSale()`.
+     * The order stays pending in the outbox, which will send it; it isn't handed to `onSaleCompleted` again, and
+     * its receipt is not shown. Otherwise does nothing.
+     */
+    continueSale() {
+      if (pending.current && confirmed.current === pending.current) result.newSale();
+    }
+  };
+  return result;
+}
+
+// src/sale/catalogue.ts
+import { findVariantByCode, formatMoney as formatMoney2, resolvePrice as resolvePrice3 } from "@tallyui/core";
+function catalogueEntries(products, traits) {
+  return products.flatMap((product) => traits.getVariants(product).map((variant) => ({ product, variant })));
+}
+function findEntryByCode(entries, code) {
+  const variant = findVariantByCode(entries.map((entry) => entry.variant), code);
+  return variant ? entries.find((entry) => entry.variant === variant) : void 0;
+}
+function variantPriceLabel(variant, currency, locale) {
+  const price = resolvePrice3(variant.prices, currency);
+  return price ? formatMoney2(price.current, locale) : void 0;
+}
+
+// src/outbox/http-transport.ts
+import { COMMANDS_PATH, PROTOCOL_HEADER, PROTOCOL_VERSION, isCommandBatchResponse } from "@tallyui/core";
+var PERMANENT_STATUSES = /* @__PURE__ */ new Set([400, 403, 413, 415, 422]);
+function createHttpCommandTransport(options) {
+  const fetch = options.fetch ?? globalThis.fetch;
+  let end = options.baseUrl.length;
+  while (end > 0 && options.baseUrl[end - 1] === "/") {
+    end--;
+  }
+  const baseUrl = options.baseUrl.slice(0, end);
+  return {
+    async send(batch) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 3e4);
+      try {
+        const response = await fetch(`${baseUrl}${COMMANDS_PATH}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
+            ...await options.getHeaders()
+          },
+          body: JSON.stringify({ commands: batch }),
+          signal: controller.signal
+        });
+        const retryAfter = response.headers.get("Retry-After");
+        const seconds = retryAfter === null ? NaN : Number(retryAfter);
+        const retry = (reason) => ({
+          kind: "retry",
+          reason,
+          ...Number.isFinite(seconds) && seconds >= 0 ? { retryAfterMs: seconds * 1e3 } : {}
+        });
+        if (response.status === 401) return { kind: "unauthorized" };
+        if (PERMANENT_STATUSES.has(response.status)) {
+          let reason = `status_${response.status}`;
+          try {
+            const body2 = await response.json();
+            if (typeof body2?.message === "string") reason = body2.message;
+            else if (typeof body2?.code === "string") reason = body2.code;
+          } catch {
+          }
+          return { kind: "refused", status: response.status, reason };
+        }
+        if (response.status !== 200) return retry(`status_${response.status}`);
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          return retry(controller.signal.aborted ? "network" : "bad_body");
+        }
+        return isCommandBatchResponse(body) ? { kind: "results", results: body.results } : retry("bad_body");
+      } catch {
+        return { kind: "retry", reason: "network" };
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+  };
+}
+
+// src/outbox/order-outbox.ts
+import { BehaviorSubject as BehaviorSubject3 } from "rxjs";
+var AUTH_FAILURES_BEFORE_PROMPT = 3;
+var NOT_REQUEUEABLE = /* @__PURE__ */ new Set(["idempotency_mismatch"]);
+function createOrderOutbox(options) {
+  const { collection, transport, deviceId } = options;
+  const batchSize = Math.min(options.batchSize ?? 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 BehaviorSubject3({ pending: 0, sending: false });
+  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;
+  async function updateState(patch = {}) {
+    const pending = await countFresh(collection, { syncStatus: "pending" });
+    state$.next({ ...state$.value, ...patch, pending });
+  }
+  function scheduleRetry(reason, retryAfterMs = 0) {
+    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);
+    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;
+      const orders = await readFresh(collection, {
+        selector: { syncStatus: "pending" },
+        sort: [{ createdAt: "asc" }],
+        limit: batchSize
+      });
+      if (!orders.length || stopped) {
+        stoppedDuringRun = stopped;
+        return;
+      }
+      const batch = orders.map((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);
+      if (outcome.kind === "retry") {
+        return scheduleRetry(outcome.reason, outcome.retryAfterMs);
+      }
+      if (outcome.kind === "unauthorized") {
+        unauthorizedSinceAccepted++;
+        if (unauthorizedSinceAccepted < AUTH_FAILURES_BEFORE_PROMPT) 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 order of orders) {
+        const result = outcome.results.find((entry) => entry.id === order.commandId);
+        if (!result) continue;
+        const [stored] = await collection.storageInstance.findDocumentsById([order.id], false);
+        if (stored?.syncStatus !== "pending" || stored.commandId !== order.commandId) continue;
+        const current = await collection.findOne(order.id).exec();
+        if (!current) continue;
+        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
+        });
+        attempts.delete(order.commandId);
+        progressed = true;
+        await updateState();
+      }
+      if (!progressed) return scheduleRetry("no_progress");
+      backoff = initialBackoff;
+      state$.next({ ...state$.value, lastRetryReason: void 0 });
+    } catch (error) {
+      scheduleRetry("error: " + (error instanceof Error ? error.message : String(error)));
+      return;
+    }
+    stoppedDuringRun = true;
+  }
+  function flush() {
+    if (running) return running;
+    stopped = false;
+    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,
+    async requeue(orderIds) {
+      const orders = (await readFresh(collection, { selector: {
+        syncStatus: "rejected",
+        ...orderIds ? { id: { $in: orderIds } } : {}
+      } })).filter((order) => !NOT_REQUEUEABLE.has(order.error?.code ?? ""));
+      let count = 0;
+      for (const order of orders) {
+        const oldCommandId = order.commandId;
+        let changed = false;
+        await (await collection.findOne(order.id).exec())?.incrementalModify((data) => {
+          changed = data.syncStatus === "rejected" && !NOT_REQUEUEABLE.has(data.error?.code ?? "");
+          if (!changed) return data;
+          data.syncStatus = "pending";
+          delete data.error;
+          data.commandId = uuidv7();
+          data.updatedAt = new Date(now()).toISOString();
+          return data;
+        });
+        if (changed) {
+          count++;
+          attempts.delete(oldCommandId);
+        }
+      }
+      await updateState();
+      if (count && !stopped) flush().catch(() => {
+      });
+      return count;
+    },
+    start() {
+      stopped = false;
+      if (!subscription) subscription = collection.$.subscribe((event) => {
+        if (event.documentData?.syncStatus === "pending" && (event.operation === "INSERT" || event.operation === "UPDATE")) {
+          insertedDuringRun = true;
+          flush().catch(() => {
+          });
+        }
+      });
+      if (!stopped) flush().catch(() => {
+      });
+    },
+    stop() {
+      stopped = true;
+      clearTimeout(timer);
+      timer = void 0;
+      subscription?.unsubscribe();
+      subscription = 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";
+var idle = { pending: 0, sending: false };
+var outboxLogger = createLogger("outbox");
+function useOrderOutbox(options) {
+  const { storeKey, deviceId } = options;
+  const latest = useRef4(options);
+  latest.current = options;
+  const current = useRef4(null);
+  const openingError = useRef4(null);
+  const loggedMismatches = useRef4(/* @__PURE__ */ new Set());
+  const [orders, setOrders] = useState4(null);
+  const [state, setState] = useState4(idle);
+  const [recent, setRecent] = useState4([]);
+  const savesInFlight = useRef4(0);
+  const [savesInFlightCount, setSavesInFlightCount] = useState4(0);
+  useEffect4(() => {
+    let active = true;
+    let dispose;
+    openingError.current = null;
+    setOrders(null);
+    setState(idle);
+    setRecent([]);
+    if (!storeKey) return;
+    void latest.current.open(storeKey).then(async (store) => {
+      if (!active) {
+        await store.close();
+        return;
+      }
+      const outbox = createOrderOutbox({ collection: store.orders, deviceId, transport: latest.current.transport(storeKey) });
+      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);
+      dispose = () => {
+        outbox.stop();
+        status.unsubscribe();
+        history.unsubscribe();
+        void store.close();
+      };
+      setOrders(store.orders);
+      outbox.start();
+    }).catch((error) => {
+      if (active) openingError.current = error;
+      latest.current.onOpenError?.(error);
+    });
+    return () => {
+      active = false;
+      current.current = null;
+      dispose?.();
+    };
+  }, [storeKey, deviceId]);
+  useEffect4(() => {
+    latest.current.onBusy?.(state.sending);
+    return () => latest.current.onBusy?.(false);
+  }, [state.sending]);
+  const ready = current.current?.storeKey === storeKey && !!storeKey;
+  return {
+    orders: ready ? orders : null,
+    state: ready ? state : idle,
+    recent: ready ? recent : [],
+    async flush() {
+      const opened = current.current;
+      if (opened && opened.storeKey === storeKey) await opened.outbox.flush();
+    },
+    async requeue(orderIds) {
+      const opened = current.current;
+      return opened && opened.storeKey === storeKey ? opened.outbox.requeue(orderIds) : 0;
+    },
+    savesInFlight: savesInFlightCount,
+    async record(posOrder) {
+      savesInFlight.current++;
+      setSavesInFlightCount(savesInFlight.current);
+      try {
+        const opened = current.current;
+        if (!opened || opened.storeKey !== storeKey) throw openingError.current ?? new Error("Orders are not ready.");
+        try {
+          await opened.orders.insert(posOrder);
+        } catch (error) {
+          const stored = error?.code === "CONFLICT" ? error.parameters.writeError : void 0;
+          const inDb = stored?.status === 409 ? stored.documentInDb : void 0;
+          if (!inDb || inDb._deleted) throw error;
+          if (!sameSale(inDb, posOrder)) throw new OrderContentMismatchError(posOrder.id);
+          if (inDb.commandId !== posOrder.commandId) {
+            outboxLogger.warn("Recorded an order stored under another commandId", {
+              orderId: posOrder.id,
+              storedCommandId: inDb.commandId,
+              recordedCommandId: posOrder.commandId
+            });
+          }
+        }
+        if (current.current === opened) void opened.outbox.flush();
+      } finally {
+        savesInFlight.current--;
+        setSavesInFlightCount(savesInFlight.current);
+      }
+    },
+    async isStored(order) {
+      const opened = current.current;
+      if (!opened || opened.storeKey !== storeKey) return false;
+      const [stored] = await opened.orders.storageInstance.findDocumentsById([order.id], false);
+      if (!stored || stored._deleted) return false;
+      if (sameSale(stored, order)) return true;
+      if (!loggedMismatches.current.has(order.id)) {
+        loggedMismatches.current.add(order.id);
+        outboxLogger.error("A stored order has this id with different content", { orderId: order.id });
+      }
+      return false;
+    }
+  };
+}
+
+// src/tender/tender-state.ts
+var MAX_TENDER_MINOR = 999999999;
+var initialTenderState = {
+  view: "select",
+  methodId: null,
+  readerId: null,
+  transport: null,
+  entryMinor: 0,
+  entryDirty: false,
+  plan: null,
+  splitView: false,
+  splitTab: "even",
+  pickedLineIds: [],
+  linesPaidBy: {}
+};
+function initTenderState({
+  methodId,
+  balanceMinor
+}) {
+  if (!methodId) return initialTenderState;
+  return { ...initialTenderState, view: "amount", methodId, entryMinor: balanceMinor };
+}
+function tenderReducer(state, action) {
+  switch (action.type) {
+    case "pick-method":
+      return {
+        ...state,
+        view: "amount",
+        methodId: action.methodId,
+        readerId: action.readerId,
+        transport: action.transport ?? null,
+        entryMinor: state.entryDirty ? state.entryMinor : action.prefillMinor,
+        entryDirty: state.entryDirty
+      };
+    case "pick-transport":
+      return { ...state, transport: action.transport };
+    case "pick-reader":
+      return { ...state, readerId: action.readerId };
+    case "key": {
+      if (state.view !== "amount") {
+        return state;
+      }
+      if (action.key === "backspace") {
+        return { ...state, entryMinor: Math.floor(state.entryMinor / 10), entryDirty: true };
+      }
+      if (action.key === "clear") {
+        return { ...state, entryMinor: 0, entryDirty: true };
+      }
+      const digit = Number(action.key);
+      if (!state.entryDirty) {
+        return { ...state, entryMinor: digit, entryDirty: true };
+      }
+      const entryMinor = state.entryMinor * 10 + digit;
+      return entryMinor > MAX_TENDER_MINOR ? state : { ...state, entryMinor };
+    }
+    case "set-entry":
+      return {
+        ...state,
+        entryMinor: Math.max(0, Math.min(action.minor, MAX_TENDER_MINOR)),
+        entryDirty: true
+      };
+    case "tender-started":
+      return { ...state, entryMinor: 0, entryDirty: false, splitView: false };
+    case "back":
+      return {
+        ...state,
+        view: "select",
+        methodId: null,
+        readerId: null,
+        transport: null,
+        entryMinor: 0,
+        entryDirty: false
+      };
+    case "tender-recorded": {
+      const linesPaidBy = { ...state.linesPaidBy };
+      if (state.plan?.kind === "items" && action.rowsSinceFrom.reduce((sum, row) => sum + row.amountMinor, 0) >= state.plan.firstMinor) {
+        for (const id2 of state.plan.lineIds) {
+          linesPaidBy[id2] ??= [...new Set(action.rowsSinceFrom.map((row) => row.title))];
+        }
+      }
+      const rows = action.rowsSinceFrom.map((row) => ({
+        minor: row.amountMinor,
+        title: row.title
+      }));
+      const plan = activePlan(state.plan, rows.length, action.balanceMinor);
+      const entryMinor = plan ? planLegs(plan, rows, action.balanceMinor).thisPaymentMinor : action.balanceMinor;
+      return {
+        ...state,
+        view: state.methodId ? "amount" : "select",
+        entryMinor,
+        entryDirty: false,
+        splitView: false,
+        pickedLineIds: [],
+        linesPaidBy
+      };
+    }
+    case "open-split":
+      return {
+        ...state,
+        splitView: true,
+        pickedLineIds: state.plan?.kind === "items" ? state.plan.lineIds.filter((id2) => !state.linesPaidBy[id2]) : state.pickedLineIds
+      };
+    case "close-split":
+      return { ...state, splitView: false };
+    case "set-split-tab":
+      return { ...state, splitTab: action.tab };
+    case "toggle-split-line":
+      if (state.linesPaidBy[action.lineId]) return state;
+      return {
+        ...state,
+        pickedLineIds: state.pickedLineIds.includes(action.lineId) ? state.pickedLineIds.filter((id2) => id2 !== action.lineId) : [...state.pickedLineIds, action.lineId]
+      };
+    case "set-plan":
+      return {
+        ...state,
+        plan: action.plan,
+        splitView: false,
+        pickedLineIds: [],
+        entryMinor: state.view === "amount" ? planLegs(action.plan, [], action.balanceMinor).thisPaymentMinor : state.entryMinor,
+        entryDirty: state.view !== "amount" && state.entryDirty
+      };
+    case "clear-plan":
+    case "arm-custom":
+      return {
+        ...state,
+        plan: null,
+        splitView: false,
+        view: action.type === "arm-custom" ? "amount" : state.view,
+        entryMinor: action.type === "clear-plan" ? action.balanceMinor : 0,
+        entryDirty: false
+      };
+    case "request-cancel":
+      return { ...state, view: "cancel", splitView: false };
+    case "reset":
+      return initialTenderState;
+  }
+}
+function appliedMinor(entryMinor, balanceMinor) {
+  return Math.max(0, Math.min(entryMinor, balanceMinor));
+}
+function changeMinor(entryMinor, appliedAmountMinor, givesChange) {
+  return givesChange ? Math.max(0, entryMinor - appliedAmountMinor) : 0;
+}
+function quickTenderedAmounts(balanceMinor, stepsMinor) {
+  if (balanceMinor === 0) {
+    return [];
+  }
+  const amounts = /* @__PURE__ */ new Set([balanceMinor]);
+  for (const stepMinor of stepsMinor) {
+    if (stepMinor <= 0) continue;
+    const remainder = balanceMinor % stepMinor;
+    amounts.add(remainder === 0 ? balanceMinor : balanceMinor + stepMinor - remainder);
+  }
+  return [...amounts].sort((left, right) => left - right);
+}
+function evenSplitShareMinor(balanceMinor, ways) {
+  if (ways < 2) {
+    return balanceMinor;
+  }
+  const wholeShare = Math.floor(balanceMinor / ways);
+  const remainder = balanceMinor % ways;
+  return wholeShare + (remainder * 2 >= ways ? 1 : 0);
+}
+function activePlan(plan, taken, balanceMinor) {
+  if (!plan || balanceMinor === 0) return null;
+  if (plan.kind !== "items" && taken >= (plan.kind === "even" ? plan.ways : 2)) return null;
+  return plan;
+}
+function planLegs(plan, rowsSinceFrom, balanceMinor) {
+  const taken = rowsSinceFrom.length;
+  const legs = rowsSinceFrom.map((row) => ({ ...row, state: "done" }));
+  const groupPaid = rowsSinceFrom.reduce((sum, row) => sum + row.minor, 0);
+  const groupLeft = plan.kind === "items" ? Math.min(balanceMinor, Math.max(0, plan.firstMinor - groupPaid)) : balanceMinor;
+  const rest = plan.kind === "items" && groupLeft === 0;
+  const ways = plan.kind === "fixed" ? 2 : Math.max(plan.ways, taken + 1);
+  const left = plan.kind === "fixed" || rest ? 1 : Math.max(1, ways - taken);
+  const amount = rest ? balanceMinor : groupLeft;
+  const each = plan.kind === "fixed" && taken === 0 ? Math.min(plan.firstMinor, balanceMinor) : evenSplitShareMinor(amount, left);
+  let remaining = amount;
+  for (let i = 0; i < left; i++) {
+    const minor2 = Math.min(remaining, i === left - 1 && plan.kind !== "fixed" ? remaining : each);
+    legs.push({ minor: minor2, state: i === 0 ? "now" : "todo" });
+    remaining -= minor2;
+  }
+  if (plan.kind === "fixed" && remaining > 0) legs.push({ minor: remaining, state: "todo" });
+  if (plan.kind === "items" && !rest && balanceMinor > groupLeft)
+    legs.push({ minor: balanceMinor - groupLeft, state: "rest" });
+  const title = plan.kind === "fixed" && taken === 0 ? plan.title : null;
+  return { legs, thisPaymentMinor: each, label: { n: taken + 1, ways, rest, title } };
+}
 export {
+  CartError,
   CurrencyProvider,
+  DISCOUNTS_UNSUPPORTED,
+  MAX_TENDER_MINOR,
+  MICROS_PER_MINOR,
+  OrderContentMismatchError,
+  PosOrderOpenClosedError,
+  RegisterApprovalRequiredError,
+  RegisterCloseIncompleteError,
+  RegisterMovementStrandedError,
+  RegisterSessionAlreadyOpenError,
+  RegisterSessionClosedError,
+  RegisterSessionRequiredError,
+  RegisterTenderInProgressError,
+  SALE_SAVING,
   TaxProvider,
-  addTax,
+  activePlan,
+  addEntryToCart,
+  addPosOrderCollection,
+  advancePerpetual,
+  allocateOrderDiscount,
+  appliedMinor,
+  backToSelling,
+  bindRegister,
+  buildClosureDocument,
   buildReceiptData,
-  calculateTax,
+  buildXReportDocument,
   callbackSink,
+  cashMovementSchema,
+  catalogueEntries,
+  changeMinor,
+  clampClosureScope,
+  closeNeedsApproval,
+  closeSession,
+  closureSchema,
+  computeOrderTax,
   consoleSink,
+  countFresh,
+  countVariance,
+  createHttpCommandTransport,
   createLogger,
   createOrderBuilder,
   createOrderManager,
+  createOrderOutbox,
   createRepository,
-  extractTax,
-  formatCurrency,
+  denominationTotal,
+  denominations,
+  deriveExpected,
+  deriveSettled,
+  ensureRegister,
+  evenSplitShareMinor,
+  exportCsv,
+  finalizeOrder,
+  findEntryByCode,
+  formatClosureDate,
+  getBoundRegisterId,
+  getDeviceId,
+  getProductStock,
+  initTenderState,
+  initialTenderState,
+  isServerDecimal,
+  labelKeys,
+  minorToDecimal,
+  mintClosureNumber,
+  mintUuid,
+  movementFieldError,
+  needsAttention,
+  nextSaleCounter,
+  normalizeAmount,
+  observeRegister$,
+  openSession,
+  openSessionSelector,
+  outboxLogger,
+  overThreshold,
+  parseMinor,
+  planLegs,
+  posOrderCollection,
+  posOrderSchema,
+  posOrdersLogger,
+  quickTenderedAmounts,
+  ratePpmFromPercent,
+  readBoundRegister,
+  readFresh,
+  readRegister,
+  recordMovement,
+  recordRegisterFact,
+  registerFactsLogger,
+  registerSessionCollection,
+  registerSessionSchema,
+  requireOpenSession,
+  resolveStoreSettings,
+  roundMicrosToMinor,
+  saleLogger,
+  sameSale,
+  searchProducts,
+  selectClosureRows,
+  stampSession,
+  startCounting,
+  stockOverlay$,
+  stockOverlayAsOf$,
+  taxLinesByRate,
+  taxMicros,
+  taxProviderProps,
+  tenderReducer,
+  toOrderCreateEnvelope,
+  unbindRegister,
+  useCurrencyCode,
   useCurrencyFormatter,
-  useTax
+  useOrderOutbox,
+  useRegisterSession,
+  useSale,
+  useStoreSettings,
+  useTax,
+  uuidv7,
+  validAmount,
+  varianceText,
+  variantPriceLabel,
+  voidMovement,
+  watchFresh,
+  withPricingContext,
+  withStockOverlay,
+  writeClosure
 };