@tallyui/pos 3.7.1 → 3.9.0

package/dist/index.js

@@ -110,7 +110,7 @@ function useCurrencyCode() {
 }
 
 // src/order/woocommerce-tax.ts
-import { minorUnitDigits, woocommerceTax } from "@tallyui/core";
+import { minorUnitDigits, woocommerceTax, woocommerceCoupons } from "@tallyui/core";
 function woocommerceLine(amountMinor, rates, inclusive, currency, roundAtSubtotal, pricesIncludeTax = inclusive) {
   const dp = minorUnitDigits(currency), factor = 10 ** dp;
   const precision = woocommerceTax.getRoundingPrecision(dp);
@@ -124,17 +124,21 @@ function woocommerceLine(amountMinor, rates, inclusive, currency, roundAtSubtota
   let result = woocommerceTax.calculateTaxes(input);
   const net = woocommerceTax.roundHalfUp(input.amount - (inclusive ? result.total : 0), precision);
   if (inclusive && rates.length) result = woocommerceTax.calculateTaxes({ ...input, amount: net, amountIncludesTax: false });
-  const taxLines = result.taxes.map((tax2) => {
-    const rate = rates.find((rate2) => rate2.id === tax2.id);
+  const taxLines = result.taxes.map((tax) => {
+    const rate = rates.find((rate2) => rate2.id === tax.id);
     return {
       code: rate.code,
       rateId: rate.id,
       compound: rate.compound,
       ratePpm: Math.round(Number(rate.rate) * 1e4),
-      taxMicros: String(Math.round(tax2.total * factor * 1e6))
+      taxMicros: String(Math.round(tax.total * factor * 1e6))
     };
   });
-  const tax = result.taxes.reduce((sum, rate) => sum + (roundAtSubtotal ? rate.total : woocommerceTax.roundTaxTotal(rate.total, dp, pricesIncludeTax)), 0);
+  return lineAmounts(net, result.taxes, taxLines, dp, roundAtSubtotal, pricesIncludeTax);
+}
+function lineAmounts(net, taxes, taxLines, dp, roundAtSubtotal, pricesIncludeTax) {
+  const factor = 10 ** dp;
+  const tax = taxes.reduce((sum, rate) => sum + (roundAtSubtotal ? rate.total : woocommerceTax.roundTaxTotal(rate.total, dp, pricesIncludeTax)), 0);
   return {
     netMinor: Math.round(woocommerceTax.roundHalfUp(net, dp) * factor),
     netMicros: String(Math.round(net * factor * 1e6)),
@@ -143,6 +147,69 @@ function woocommerceLine(amountMinor, rates, inclusive, currency, roundAtSubtota
     taxMicros: taxLines.reduce((sum, rate) => sum + BigInt(rate.taxMicros), 0n).toString()
   };
 }
+function woocommerceCouponReplay(lines, codes, context, getTaxRates, currency, roundAtSubtotal, pricesIncludeTax) {
+  const dp = minorUnitDigits(currency), factor = 10 ** dp;
+  const inputLines = lines.filter((line) => line.unitPriceMinor >= 0);
+  const lineItems = inputLines.map((line) => {
+    const productId = Number(line.productId), variationId = Number(line.variantId);
+    const net = (Number(line.netMicros) / (factor * 1e6)).toFixed(6);
+    const taxes = line.taxLines.map((tax2) => {
+      const amount = (Number(tax2.taxMicros) / (factor * 1e6)).toFixed(6);
+      return { id: tax2.rateId, subtotal: amount, total: amount };
+    });
+    const tax = taxes.reduce((sum, row) => sum + Number(row.total), 0).toFixed(6);
+    return {
+      product_id: !line.custom && Number.isSafeInteger(productId) && productId >= 0 ? productId : 0,
+      ...Number.isSafeInteger(variationId) && variationId >= 0 ? { variation_id: variationId } : {},
+      quantity: line.quantity,
+      tax_class: line.taxClass ?? "",
+      ...line.taxStatus === "none" ? { tax_status: "none" } : {},
+      subtotal: net,
+      total: net,
+      taxes,
+      subtotal_tax: tax,
+      total_tax: tax
+    };
+  });
+  const taxRates = /* @__PURE__ */ new Map();
+  for (const line of inputLines) for (const rate of getTaxRates(line.taxClass)) {
+    const taxClass = woocommerceTax.normalizeTaxClass(line.taxClass);
+    taxRates.set(JSON.stringify([rate.id, taxClass]), {
+      id: rate.id,
+      rate: rate.rate,
+      compound: rate.compound,
+      order: rate.priority,
+      priority: rate.priority,
+      class: taxClass
+    });
+  }
+  const result = woocommerceCoupons.recalculateCoupons({
+    lineItems,
+    couponLines: codes.map((code) => ({ code })),
+    couponConfigs: new Map(codes.map((code) => [code, context.configs.get(code)])),
+    pricesIncludeTax,
+    calcDiscountsSequentially: context.calcDiscountsSequentially,
+    productCategories: new Map(context.productCategories),
+    taxRates: [...taxRates.values()],
+    taxRoundAtSubtotal: roundAtSubtotal,
+    dp
+  });
+  let index = 0;
+  return {
+    lines: lines.map((line) => {
+      if (line.unitPriceMinor < 0) return line;
+      const item = result.lineItems[index++];
+      const taxes = line.taxLines.map((tax) => ({ total: Number(item.taxes?.find((row) => row.id === tax.rateId)?.total ?? "0") }));
+      const taxLines = line.taxLines.map((tax, index2) => ({ ...tax, taxMicros: String(Math.round(taxes[index2].total * factor * 1e6)) }));
+      return { ...line, ...lineAmounts(Number(item.total), taxes, taxLines, dp, roundAtSubtotal, pricesIncludeTax) };
+    }),
+    coupons: result.couponLines.map((coupon, index2) => ({
+      code: codes[index2],
+      discountMinor: Math.round(woocommerceTax.roundHalfUp(Number(coupon.discount), dp) * factor),
+      discountTaxMinor: Math.round(woocommerceTax.roundHalfUp(Number(coupon.discount_tax), dp) * factor)
+    }))
+  };
+}
 function woocommerceTotals(lines, fees, shipping, currency, roundAtSubtotal, inclusive) {
   const dp = minorUnitDigits(currency), factor = 10 ** dp;
   const net = (line) => Number(line.netMicros) / (factor * 1e6);
@@ -611,7 +678,7 @@ function assertDisplayResidue(residue, convertedLines, conversions) {
   if (Math.abs(residue) > bound) throw new Error(`Display residue ${residue} exceeds its bound of ${bound} (ADR-063)`);
 }
 function createOrderBuilder(options) {
-  const { taxContext } = options;
+  const { taxContext, couponContext } = options;
   const currency = options.currency.toUpperCase();
   const orderId = options.id ?? uid();
   const woo = taxContext.rounding?.granularity === "woocommerce" && taxContext.getTaxRates ? taxContext.rounding : void 0;
@@ -628,6 +695,7 @@ function createOrderBuilder(options) {
   let payments = [];
   let customer = null;
   let note = "";
+  let couponCodes = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const subject = new BehaviorSubject(buildOrder());
   function recalculateLine(line, orderDiscountMinor = 0) {
@@ -674,16 +742,26 @@ function createOrderBuilder(options) {
     return Math.max(0, Math.min(discount.value, base));
   }
   function buildOrder() {
-    const lineAmounts = lineItems.map((li) => woo ? li.unitPriceMinor * li.quantity - li.discountMinor : li.netMinor);
-    const base = lineAmounts.reduce((sum, amount) => sum + Math.max(0, amount), 0);
+    const lineAmounts2 = lineItems.map((li) => woo ? li.unitPriceMinor * li.quantity - li.discountMinor : li.netMinor);
+    const base = lineAmounts2.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 shares = allocateOrderDiscount(lineAmounts2, recalcedOrderDiscounts.reduce((sum, d) => sum + d.amountMinor, 0));
+    const displaySourceLines = lineItems.map((li, index) => recalculateLine(li, shares[index]));
+    const replay = woo && couponCodes.length ? woocommerceCouponReplay(
+      displaySourceLines,
+      couponCodes,
+      couponContext,
+      taxContext.getTaxRates,
+      currency,
+      woo.roundAtSubtotal,
+      taxContext.pricesIncludeTax
+    ) : void 0;
+    const lines = replay?.lines ?? displaySourceLines;
     if (woo) shipping = shipping.map((charge) => ({ ...charge, ...recalculateCharge(charge.id, charge, true) }));
     const wooTotals = woo ? woocommerceTotals(lines, fees, shipping, currency, woo.roundAtSubtotal, taxContext.pricesIncludeTax) : void 0;
     const { subtotalMinor } = wooTotals ?? sumLines(lines, taxContext.rounding);
@@ -700,7 +778,7 @@ function createOrderBuilder(options) {
     }
     const discountMinor = lines.reduce((sum, li) => sum + li.discountMinor, 0);
     const taxInclusive = taxContext.pricesIncludeTax;
-    const figures = lines.map((li) => {
+    const figures = displaySourceLines.map((li) => {
       const returned = li.unitPriceMinor < 0;
       const discounts = returned ? [] : li.discounts.map((d) => ({
         discountId: d.id,
@@ -714,10 +792,11 @@ function createOrderBuilder(options) {
     });
     const displayLines = figures.map((f) => f.line);
     const orderDiscountDisplay = figures.reduce((sum, f) => sum + f.shareMinor, 0);
+    const displayCoupons = replay?.coupons.map(({ code, discountMinor: discountMinor2, discountTaxMinor }) => ({ code, amountMinor: discountMinor2 + (taxInclusive ? discountTaxMinor : 0) }));
     const displayDiscount = displayLines.reduce(
       (sum, line) => line.discounts.reduce((lineSum, d) => lineSum + d.amountMinor, sum),
       orderDiscountDisplay
-    );
+    ) + (displayCoupons?.reduce((sum, row) => sum + row.amountMinor, 0) ?? 0);
     const chargeRows = (items) => items.map(({ id: id2, name, amountMinor, netMinor, totalMinor: totalMinor2 }) => ({ id: id2, name, amountMinor: woo ? taxInclusive ? totalMinor2 : netMinor : amountMinor }));
     const displayFees = chargeRows(fees), displayShipping = chargeRows(shipping);
     let displaySubtotal = (taxInclusive ? totalMinor : totalMinor - taxMinor) + displayDiscount - [...displayFees, ...displayShipping].reduce((sum, charge) => sum + charge.amountMinor, 0);
@@ -729,11 +808,11 @@ function createOrderBuilder(options) {
       if (charge) displaySubtotal -= residue;
       residue = displaySubtotal - displayLines.reduce((sum, line) => sum + line.amountMinor, 0);
     }
-    const converted = lines.flatMap((li, index) => li.taxInclusive === taxInclusive ? [] : [index]);
+    const converted = displaySourceLines.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)
+      displaySourceLines[index].netMinor,
+      displaySourceLines[index].orderDiscountMinor,
+      ...displaySourceLines[index].discounts.map((d) => d.amountMinor)
     ].filter((x) => x !== 0).length, 0);
     assertDisplayResidue(residue, converted.length, conversions);
     let left = residue;
@@ -762,6 +841,7 @@ function createOrderBuilder(options) {
       totalMinor,
       lines: displayLines,
       orderDiscountMinor: orderDiscountDisplay,
+      ...displayCoupons ? { coupons: displayCoupons } : {},
       ...fees.length ? { fees: displayFees } : {},
       ...shipping.length ? { shipping: displayShipping } : {}
     };
@@ -772,6 +852,7 @@ function createOrderBuilder(options) {
       id: orderId,
       status: "draft",
       lineItems: lines,
+      ...replay ? { coupons: replay.coupons } : {},
       ...fees.length ? { fees: [...fees] } : {},
       ...shipping.length ? { shipping: [...shipping] } : {},
       discounts: recalcedOrderDiscounts,
@@ -1038,6 +1119,17 @@ function createOrderBuilder(options) {
       note = n;
       emit();
     },
+    setCoupons(codes) {
+      const normalized = [...new Set(codes.map((code) => code.trim().toLowerCase()))];
+      if (normalized.length && !couponContext) throw new Error("Coupon context is required");
+      for (const code of normalized) {
+        const config = couponContext.configs.get(code);
+        if (!config) throw new RangeError(`Unknown coupon ${code}`);
+        if (config.exclude_sale_items) throw new RangeError(`Coupon ${code} excludes sale items`);
+      }
+      couponCodes = normalized;
+      emit();
+    },
     clear() {
       lineItems = [];
       fees = [];
@@ -1046,6 +1138,7 @@ function createOrderBuilder(options) {
       payments = [];
       customer = null;
       note = "";
+      couponCodes = [];
       emit();
     },
     getSnapshot() {
@@ -1218,9 +1311,10 @@ var orderDraftSchema = {
   required: ["id", "data"]
 };
 async function writeOrderDraft(drafts, snapshot) {
+  const { coupons: _coupons, ...draft } = snapshot;
   await drafts.upsert({
     id: snapshot.id,
-    data: JSON.stringify(snapshot),
+    data: JSON.stringify(draft),
     customerName: snapshot.customer?.name ?? "",
     itemCount: snapshot.lineItems.length,
     total: snapshot.totalMinor,
@@ -2361,10 +2455,18 @@ function movementFieldError(input) {
 }
 
 // src/register/expected.ts
+function refundAmounts(refund) {
+  const result = refund.result;
+  if (typeof result !== "object" || result === null || Object.getPrototypeOf(result) !== Object.prototype && Object.getPrototypeOf(result) !== null) return [];
+  const byMethod = result.byMethod;
+  if (typeof byMethod !== "object" || byMethod === null || Object.getPrototypeOf(byMethod) !== Object.prototype && Object.getPrototypeOf(byMethod) !== null) return [];
+  return Object.entries(byMethod).filter(([method, amount]) => method.length > 0 && Number.isSafeInteger(amount) && amount >= 0);
+}
 function deriveExpected({
   session,
   movements,
-  ledgerRowsBySession
+  ledgerRowsBySession,
+  refunds
 }) {
   const totals = { cash: session.countedFloatMinor };
   for (const row of ledgerRowsBySession) {
@@ -2380,6 +2482,10 @@ function deriveExpected({
     if (row.type === "paid_in") totals.cash += row.amountMinor;
     if (row.type === "paid_out") totals.cash -= row.amountMinor;
   }
+  for (const refund of refunds ?? []) {
+    if (refund.status !== "applied" || refund.sessionId !== session.id) continue;
+    for (const [method, amount] of refundAmounts(refund)) totals[method] = (totals[method] ?? 0) - amount;
+  }
   return totals;
 }
 
@@ -2813,6 +2919,20 @@ var RegisterNeedsUpgradeError = class extends Error {
     this.name = "RegisterNeedsUpgradeError";
   }
 };
+var RegisterSessionConflictError = class extends Error {
+  code = "REGISTER_SESSION_CONFLICT";
+  constructor() {
+    super("This register is open on another till. Take it over or choose another register.");
+    this.name = "RegisterSessionConflictError";
+  }
+};
+var RegisterTakeOverError = class extends Error {
+  constructor(code) {
+    super(code === "REGISTER_TAKEOVER_UNSUPPORTED" ? "This store cannot take over a register. Choose another register." : "Taking over this register is still waiting for the store.");
+    this.code = code;
+    this.name = "RegisterTakeOverError";
+  }
+};
 var RegisterMovementAmountError = class extends Error {
   constructor(type, amountMinor) {
     super(`movement_amount_invalid:${type}:${amountMinor}`);
@@ -2840,7 +2960,8 @@ var TRANSITIONS = {
   counting: ["open", "closed"],
   closed: [],
   conflict: [],
-  superseded: []
+  superseded: [],
+  abandoned: []
 };
 function isKnownSessionStatus(status) {
   return Object.hasOwn(TRANSITIONS, status);
@@ -2858,6 +2979,7 @@ async function requireLiveSession(sessions, id2) {
   if (!session) throw new RegisterSessionRequiredError();
   if (!isKnownSessionStatus(session.status)) throw new RegisterNeedsUpgradeError();
   if (session.status === "closed") throw new RegisterSessionClosedError();
+  if (session.status === "abandoned") throw new RegisterSessionClosedError();
   return session;
 }
 var openSessionSelector = { status: "open" };
@@ -3034,6 +3156,7 @@ async function writeClosure({
   otherTenders,
   movements,
   orders,
+  refunds,
   tillExpected,
   labels,
   resolveCashierName,
@@ -3051,6 +3174,7 @@ async function writeClosure({
     return existing;
   }
   const bound = orders.filter((order) => order.sessionId === session.id);
+  const countedRefunds = (refunds ?? []).filter((refund) => refund.status === "applied" && refund.sessionId === session.id);
   const rows = bound.flatMap(
     (order) => order.payments.map((payment) => ({
       session_id: order.sessionId,
@@ -3064,7 +3188,8 @@ async function writeClosure({
   const till_expected = tillExpected ?? deriveExpected({
     session: { id: session.id, countedFloatMinor: session.counted_float_minor },
     movements: entries,
-    ledgerRowsBySession: rows
+    ledgerRowsBySession: rows,
+    refunds
   });
   const counts = { cash: counted, ...otherTenders };
   const sum = (values) => values.reduce((total, value) => total + value, 0);
@@ -3073,6 +3198,11 @@ async function writeClosure({
     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 };
   }
+  for (const refund of countedRefunds) {
+    for (const [method, amount] of refundAmounts(refund)) {
+      payment_methods[method] = { sales_minor: payment_methods[method]?.sales_minor ?? 0, refunds_minor: (payment_methods[method]?.refunds_minor ?? 0) + amount };
+    }
+  }
   const taxRates = /* @__PURE__ */ new Map();
   const roundings = /* @__PURE__ */ new Set();
   for (const order of bound) {
@@ -3108,7 +3238,7 @@ async function writeClosure({
       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,
+    period_refunds_total_minor: sum(countedRefunds.flatMap((refund) => refundAmounts(refund).map(([, amount]) => amount))),
     perpetual_sales_total_minor: 0,
     perpetual_refunds_total_minor: 0,
     unsynced_count: unsynced.length,
@@ -3145,7 +3275,11 @@ async function writeClosure({
         voided_by: voided_by ?? null
       })),
       transaction_count: bound.length,
-      refund_count: 0,
+      refund_count: countedRefunds.length,
+      ...refunds !== void 0 ? {
+        refund_ids: countedRefunds.map((refund) => refund.id),
+        pending_refund_ids: refunds.filter((refund) => refund.status === "pending" && refund.sessionId === session.id).map((refund) => refund.id)
+      } : {},
       cashiers: [...new Set(bound.map((order) => order.cashierRef ?? "").filter(Boolean))].map((id2) => ({
         id: id2,
         name: resolveCashierName?.(id2) || id2
@@ -3603,8 +3737,17 @@ var registerCommandSchema = {
   indexes: [["registerId", "seq"], ["syncStatus", "registerId", "seq"]]
 };
 var registerCommandCollection = () => ({ schema: registerCommandSchema });
-function sessionOpenCommand(s) {
-  return { key: `session.open:${s.id}`, type: "register.session.open", version: 1, payload: {
+function deviceNameOf(name) {
+  let trimmed = name?.trim();
+  if (trimmed && trimmed.length > 64) {
+    const last = trimmed.charCodeAt(63);
+    trimmed = trimmed.slice(0, last >= 55296 && last <= 56319 ? 63 : 64).trimEnd();
+  }
+  return trimmed || void 0;
+}
+function sessionOpenCommand(s, v2) {
+  const deviceName = deviceNameOf(v2?.deviceName);
+  return { key: `session.open:${s.id}`, type: "register.session.open", version: v2 ? 2 : 1, payload: {
     sessionId: s.id,
     registerId: s.register_id,
     openedAt: s.opened_at_gmt,
@@ -3613,7 +3756,8 @@ function sessionOpenCommand(s) {
     ...s.business_day == null ? {} : { businessDay: s.business_day },
     ...s.opened_by == null ? {} : { openedBy: s.opened_by },
     ...s.expected_float_minor == null ? {} : { expectedFloatMinor: s.expected_float_minor },
-    ...s.opening_variance_minor == null ? {} : { openingVarianceMinor: s.opening_variance_minor }
+    ...s.opening_variance_minor == null ? {} : { openingVarianceMinor: s.opening_variance_minor },
+    ...deviceName === void 0 ? {} : { deviceName }
   } };
 }
 function sessionTransitionCommand(s) {
@@ -3670,7 +3814,7 @@ function closureCommand(c) {
   } };
 }
 var chains = /* @__PURE__ */ new WeakMap();
-function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed }) {
+function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed, registerContract, deviceName }) {
   const sentStatus = (s) => s.status === "open" || s.status === "counting" || s.status === "closed";
   let registers = chains.get(commands);
   if (!registers) chains.set(commands, registers = /* @__PURE__ */ new Map());
@@ -3681,7 +3825,7 @@ function reconcileRegisterCommands({ commands, sessions, movements, closures, ho
     const transitioned = new Set((await readFresh(commands, { selector: { registerId, type: "register.session.transition" } })).map(({ payload }) => payload.sessionId));
     const rows = await readFresh(sessions, { selector: { register_id: registerId } });
     const complete = new Set((await commands.storageInstance.findDocumentsById(rows.flatMap((session) => [`session.open:${session.id}`, ...session.status === "closed" && session.closure_id ? [`closure.submit:${session.closure_id}`] : []]), false)).map(({ key }) => key));
-    const facts = await Promise.all(rows.filter((session) => session.status !== "closed" || (session.status_at == null || session.status_at >= since || complete.has(`session.open:${session.id}`)) && !complete.has(`closure.submit:${session.closure_id}`)).map(async (session) => {
+    const facts = await Promise.all(rows.filter((session) => session.status !== "abandoned" && (session.status !== "closed" || (session.status_at == null || session.status_at >= since || complete.has(`session.open:${session.id}`)) && !complete.has(`closure.submit:${session.closure_id}`))).map(async (session) => {
       const [entries, closureRows] = await Promise.all([
         readFresh(movements, { selector: { session_id: session.id } }),
         session.closure_id ? closures.storageInstance.findDocumentsById([session.closure_id], false) : Promise.resolve([])
@@ -3693,7 +3837,7 @@ function reconcileRegisterCommands({ commands, sessions, movements, closures, ho
       );
       if (session.status_at != null && sentStatus(session)) events.push(sessionTransitionCommand({ ...session, status_at: session.status_at }));
       return { session, number: closureRows[0]?.number, built: [
-        sessionOpenCommand(session),
+        (registerContract ?? 0) >= 2 ? sessionOpenCommand(session, { deviceName }) : sessionOpenCommand(session),
         ...events,
         ...closureRows.map((closure) => closureCommand(closure))
       ] };
@@ -3721,6 +3865,95 @@ function reconcileRegisterCommands({ commands, sessions, movements, closures, ho
   return run;
 }
 
+// src/register/register-adoption.ts
+var chains2 = /* @__PURE__ */ new WeakMap();
+async function adoptRegisterResults({ commands, sessions, registerId }) {
+  const run = (chains2.get(commands) ?? Promise.resolve()).then(async () => {
+    const [answers, transitions, rows] = await Promise.all([
+      readFresh(commands, { selector: { registerId, syncStatus: { $in: ["applied", "rejected"] } }, sort: [{ seq: "asc" }, { key: "asc" }] }),
+      readFresh(commands, { selector: { registerId, type: "register.session.transition" }, sort: [{ seq: "desc" }, { key: "desc" }] }),
+      readFresh(sessions, { selector: { register_id: registerId } })
+    ]);
+    for (const session of rows) {
+      if (session.status === "conflict" && answers.some((answer) => answer.payload.sessionId === session.id && answer.syncStatus === "rejected" && answer.error?.code === "register_session_abandoned")) {
+        await finishAbandon({ commands, sessions, sessionId: session.id });
+        continue;
+      }
+      const latest = transitions.find(({ payload }) => payload.sessionId === session.id);
+      const modify = (doc) => {
+        let next = doc;
+        for (const answer of answers) {
+          if (!isKnownSessionStatus(next.status) || next.status === "closed" || next.status === "superseded" || next.status === "abandoned") break;
+          if (answer.payload.sessionId !== doc.id) continue;
+          if (answer.syncStatus === "rejected") {
+            if (answer.error?.code === "register_session_superseded" && (next.status === "open" || next.status === "counting")) next = { ...next, status: "superseded" };
+            else if (answer.type === "register.session.open" && answer.error?.code === "register_session_already_open" && (next.status === "open" || next.status === "counting")) next = { ...next, status: "conflict" };
+          } else if (answer.type === "register.session.open") {
+            const resumed = answer.result?.resumed?.fromSessionId;
+            if (typeof resumed === "string" && next.server_session_id == null) next = { ...next, server_session_id: resumed };
+            if (next.status === "conflict") next = { ...next, status: latest?.payload.status === "counting" ? "counting" : "open" };
+          }
+        }
+        return next;
+      };
+      if (modify(session) === session) continue;
+      const row = await sessions.findOne(session.id).exec();
+      if (row) await row.incrementalModify(modify);
+    }
+  }).catch((error) => {
+    registerCommandsLogger.error("Register result adoption failed", { context: { registerId, error: String(error) } });
+  });
+  chains2.set(commands, run.then(() => void 0, () => void 0));
+  return run;
+}
+async function takeOverSession({ commands, sessions, sessionId, now, registerContract }) {
+  if ((registerContract ?? 0) < 2) throw new RegisterTakeOverError("REGISTER_TAKEOVER_UNSUPPORTED");
+  const run = (chains2.get(commands) ?? Promise.resolve()).then(async () => {
+    const [session] = await readFresh(sessions, { selector: { id: sessionId } });
+    const row = await commands.findOne(`session.open:${sessionId}`).exec();
+    if (session?.status !== "conflict" || !row) throw new RegisterSessionRequiredError();
+    await row.incrementalModify((doc) => {
+      if (doc.syncStatus !== "rejected" || doc.error?.code !== "register_session_already_open" || typeof doc.error.data?.sessionId !== "string") throw new RegisterSessionRequiredError();
+      const { error, ...rest } = doc;
+      return {
+        ...rest,
+        commandId: uuidv7(),
+        version: 2,
+        syncStatus: "pending",
+        payload: { ...doc.payload, supersedes: error.data.sessionId },
+        updatedAt: now ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+    });
+  });
+  chains2.set(commands, run.then(() => void 0, () => void 0));
+  return run;
+}
+async function finishAbandon({ commands, sessions, sessionId, now }) {
+  const rows = await readFresh(commands, { selector: { "payload.sessionId": sessionId, syncStatus: "pending" } });
+  for (const row of rows) {
+    await (await commands.findOne(row.key).exec(true)).incrementalModify((doc) => doc.syncStatus !== "pending" ? doc : {
+      ...doc,
+      syncStatus: "rejected",
+      error: { code: "register_session_abandoned", message: "The cashier chose another register." },
+      updatedAt: now ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  await (await sessions.findOne(sessionId).exec(true)).incrementalModify((doc) => doc.status === "conflict" ? { ...doc, status: "abandoned" } : doc);
+}
+async function abandonSession(input) {
+  const { commands, sessions, sessionId } = input;
+  const run = (chains2.get(commands) ?? Promise.resolve()).then(async () => {
+    const [session] = await readFresh(sessions, { selector: { id: sessionId } });
+    if (session?.status === "abandoned") return;
+    if (session?.status !== "conflict") throw new RegisterSessionRequiredError();
+    const [open] = await readFresh(commands, { selector: { key: `session.open:${sessionId}` } });
+    if (open?.syncStatus === "pending") throw new RegisterTakeOverError("REGISTER_TAKEOVER_PENDING");
+    await finishAbandon(input);
+  });
+  chains2.set(commands, run.then(() => void 0, () => void 0));
+  return run;
+}
+
 // src/register/use-register-session.ts
 var RegisterTenderInProgressError = class extends Error {
   constructor() {
@@ -3761,7 +3994,7 @@ var reservationOf = (register, storeKey, registerId) => register?.stores[storeKe
 var unwritten = (row, closureRows) => row.status === "closed" && row.closure_id === row.id && !closureRows.some((closure) => closure.id === row.id);
 function currentSession(rows, closureRows, reservation) {
   if (rows.some((row) => !isKnownSessionStatus(row.status))) return null;
-  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;
+  return (reservation && !reservation.applied ? rows.find((row) => row.id === reservation.row.session_id) : void 0) ?? rows.find((row) => row.status === "open" || row.status === "counting") ?? rows.find((row) => row.status === "conflict") ?? rows.find((row) => unwritten(row, closureRows)) ?? null;
 }
 function ledgerRows(orders) {
   return orders.flatMap((order) => order.payments.map((payment) => ({
@@ -3774,11 +4007,11 @@ function ledgerRows(orders) {
 }
 function useRegisterSession(options) {
   const { sessions, movements, closures, orders, register, storeKey, registerId, enabled, actor, timezone, tenderInProgress, expectedCloseTime, labels } = options;
-  const { commands } = options;
+  const { commands, refunds } = options;
   const commandEnabled = (options.capabilities?.register ?? 0) >= 1;
   const commandTarget = useMemo3(
-    () => enabled && commandEnabled && commands && sessions && movements && closures && register && registerId ? { commands, sessions, movements, closures, host: register, storeKey, registerId } : null,
-    [enabled, commandEnabled, commands, sessions, movements, closures, register, storeKey, registerId]
+    () => enabled && commandEnabled && commands && sessions && movements && closures && register && registerId ? { commands, sessions, movements, closures, host: register, storeKey, registerId, registerContract: options.capabilities?.register, deviceName: options.deviceName } : null,
+    [enabled, commandEnabled, commands, sessions, movements, closures, register, storeKey, registerId, options.capabilities?.register, options.deviceName]
   );
   const commandTargetRef = useRef2(commandTarget);
   commandTargetRef.current = commandTarget;
@@ -3793,21 +4026,30 @@ function useRegisterSession(options) {
     });
   };
   useEffect3(reconcile, [commandTarget]);
+  useEffect3(() => {
+    if (!commandTarget) return;
+    const subscription = commandTarget.commands.find({ selector: { registerId: commandTarget.registerId } }).$.subscribe(() => {
+      void adoptRegisterResults(commandTarget);
+    });
+    return () => subscription.unsubscribe();
+  }, [commandTarget]);
   const source = useMemo3(() => {
-    if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register) return null;
+    if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register || refunds === null) 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: [] });
+      if (!current2) return of({ rows, closureRows, reservation, entries: [], sales: [], refundRows: [] });
       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 })));
+        watchFresh(orders, { selector: { sessionId: current2.id } }),
+        commandTarget ? watchFresh(commandTarget.commands, { selector: { key: `session.open:${current2.id}` } }) : of([]),
+        refunds ? watchFresh(refunds, { selector: { sessionId: current2.id } }) : of([])
+      ]).pipe(map5(([entries2, sales2, opens, refundRows]) => ({ rows, closureRows, reservation, entries: entries2, sales: sales2, open: opens[0], refundRows })));
     }));
-  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId]);
+  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId, commandTarget, refunds]);
   const tender = useRef2(tenderInProgress);
   tender.current = tenderInProgress;
   const closing = useSyncExternalStore(subscribeClosing, () => closingByRegister.has(registerId ?? ""));
@@ -3862,9 +4104,11 @@ function useRegisterSession(options) {
     }
   }, [data, source]);
   const session = data ? currentSession(data.rows, data.closureRows, data.reservation) : null;
+  const refusal = data?.open?.error?.data;
+  const conflict = session?.status !== "conflict" || !commandTarget ? void 0 : data?.open?.syncStatus === "pending" && typeof data.open.payload.supersedes === "string" ? { sessionId: data.open.payload.supersedes, takingOver: true } : data?.open?.syncStatus === "rejected" && refusal ? { sessionId: refusal.sessionId, openedAt: refusal.openedAt, openedBy: refusal.openedBy, deviceName: refusal.deviceName, takingOver: false } : void 0;
   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 expected = session ? deriveExpected({ session: { id: session.id, countedFloatMinor: session.counted_float_minor }, movements: entries, ledgerRowsBySession: ledgerRows(sales), refunds: data?.refundRows ?? [] }) : {};
   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();
@@ -3874,8 +4118,8 @@ function useRegisterSession(options) {
     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 };
+    if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register || refunds === null) throw new RegisterSessionRequiredError();
+    return { sessions, movements, closures, orders, registerId, register, refunds };
   };
   const current = () => {
     if (!session) throw new RegisterSessionRequiredError();
@@ -3887,6 +4131,8 @@ function useRegisterSession(options) {
   const nameOf = (id2) => !id2 ? "" : id2 === actor.id ? actor.name : labels?.resolveCashierName?.(id2) ?? "";
   return {
     session,
+    /** The other till's live session, or the session this till is waiting to take over. */
+    conflict,
     /** Any unknown session status in the current snapshot means the register needs upgrade. */
     needsUpgrade: data?.rows.some((row) => !isKnownSessionStatus(row.status)) ?? false,
     movements: entries,
@@ -3901,17 +4147,38 @@ function useRegisterSession(options) {
     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,
+    saleSession: session && sessions && (session.status === "open" || session.status === "counting") ? { 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: {
+      takeOver: async () => {
+        if (!commandTarget) throw new RegisterSessionRequiredError();
+        const row = currentSession(
+          await readFresh(commandTarget.sessions, { selector: { register_id: commandTarget.registerId } }),
+          await readFresh(commandTarget.closures, { selector: { register_id: commandTarget.registerId } }),
+          reservationOf(await readRegister(commandTarget.host), commandTarget.storeKey, commandTarget.registerId)
+        );
+        if (row?.status !== "conflict") throw new RegisterSessionRequiredError();
+        await takeOverSession({ ...commandTarget, sessionId: row.id, registerContract: options.capabilities?.register });
+      },
+      chooseAnotherRegister: async () => {
+        if (!commandTarget) throw new RegisterSessionRequiredError();
+        const row = currentSession(
+          await readFresh(commandTarget.sessions, { selector: { register_id: commandTarget.registerId } }),
+          await readFresh(commandTarget.closures, { selector: { register_id: commandTarget.registerId } }),
+          reservationOf(await readRegister(commandTarget.host), commandTarget.storeKey, commandTarget.registerId)
+        );
+        if (row?.status !== "conflict") throw new RegisterSessionRequiredError();
+        await abandonSession({ ...commandTarget, sessionId: row.id });
+      },
       /**
        * 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.
        * An unknown stored status refuses with `RegisterNeedsUpgradeError`.
+       * A conflict session refuses with `RegisterSessionConflictError`; superseded and abandoned sessions do not block.
        */
       openSession: async (input) => {
         const key = registerId ?? "";
@@ -3920,7 +4187,8 @@ function useRegisterSession(options) {
           const { sessions: sessions2, closures: closures2, registerId: registerId2, register: register2 } = live();
           const rows = await readFresh(sessions2, { selector: { register_id: registerId2 } });
           if (rows.some((row2) => !isKnownSessionStatus(row2.status))) throw new RegisterNeedsUpgradeError();
-          if (rows.some((row2) => row2.status !== "closed")) throw new RegisterSessionAlreadyOpenError();
+          if (rows.some((row2) => row2.status === "conflict")) throw new RegisterSessionConflictError();
+          if (rows.some((row2) => row2.status === "open" || row2.status === "counting")) 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))) {
@@ -3988,7 +4256,7 @@ function useRegisterSession(options) {
         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 { sessions: sessions2, movements: movements2, closures: closures2, orders: orders2, register: register2, refunds: refunds2 } = live();
           const open = current();
           const stored = await readSession(sessions2, open.id);
           if (!stored) throw new RegisterSessionRequiredError();
@@ -3996,7 +4264,8 @@ function useRegisterSession(options) {
             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 } }))
+              ledgerRowsBySession: ledgerRows(await readFresh(orders2, { selector: { sessionId: stored.id } })),
+              refunds: refunds2 ? await readFresh(refunds2, { selector: { sessionId: stored.id } }) : void 0
             });
             if (closeNeedsApproval(input.counted.cash ?? 0, fresh.cash ?? 0, options.varianceThreshold)) throw new RegisterApprovalRequiredError();
           }
@@ -4014,6 +4283,7 @@ function useRegisterSession(options) {
             softwareVersion: options.softwareVersion,
             movements: await readFresh(movements2, { selector: { session_id: closed.id } }),
             orders: await readFresh(orders2, { selector: { sessionId: closed.id } }),
+            refunds: refunds2 ? await readFresh(refunds2, { selector: { sessionId: closed.id } }) : void 0,
             resolveCashierName: labels?.resolveCashierName,
             labels: {
               register_name: labels?.registerName ?? "",
@@ -5203,7 +5473,7 @@ function plainCommand({
   });
 }
 function createRegisterOutbox(options) {
-  const { collection, transport, deviceId } = options;
+  const { collection, sessions, transport, deviceId } = options;
   const size = options.batchSize;
   const batchSize = Math.max(1, Math.min(typeof size === "number" && Number.isFinite(size) ? Math.floor(size) : 10, 10));
   const initialBackoff = options.initialBackoffMs ?? 1e3;
@@ -5223,6 +5493,7 @@ function createRegisterOutbox(options) {
   let running;
   let timer;
   let subscription;
+  let sessionsSubscription;
   let stopped = false;
   let insertedDuringRun = false;
   let stoppedDuringRun = false;
@@ -5244,7 +5515,11 @@ function createRegisterOutbox(options) {
     const at2 = now();
     for (const { commandId } of commands) clocks.set(commandId, { ...clocks.get(commandId) ?? { since: at2, firstFailedAt: at2 }, seq: ++failureSeq, reason });
   }
+  function isNonBlocking(command, abandoned) {
+    return NON_BLOCKING_REJECTIONS.has(command.error?.code ?? "") || command.error?.code === "register_session_already_open" && typeof command.payload.sessionId === "string" && abandoned.has(command.payload.sessionId);
+  }
   async function updateState(patch = {}) {
+    const abandoned = new Set(sessions && clocks.size ? (await readFresh(sessions, { selector: { status: "abandoned" } })).map((session) => session.id) : []);
     const pending = await countFresh(collection, { syncStatus: "pending" });
     const sendable2 = /* @__PURE__ */ new Set();
     const blocked = /* @__PURE__ */ new Set();
@@ -5253,7 +5528,7 @@ function createRegisterOutbox(options) {
       sort: [{ seq: "asc" }, { key: "asc" }]
     })) {
       if (command.syncStatus === "rejected") {
-        if (!NON_BLOCKING_REJECTIONS.has(command.error?.code ?? "")) blocked.add(command.registerId);
+        if (!isNonBlocking(command, abandoned)) blocked.add(command.registerId);
       } else if (!blocked.has(command.registerId)) sendable2.add(command.commandId);
     }
     for (const id2 of clocks.keys()) if (!sendable2.has(id2)) clocks.delete(id2);
@@ -5282,6 +5557,7 @@ function createRegisterOutbox(options) {
       if (options.isEnabled?.() === false) return;
       const pending = await readFresh(collection, { selector: { syncStatus: "pending" } });
       const registerIds = [...new Set(pending.map((command) => command.registerId))].sort();
+      const abandoned = new Set(sessions ? (await readFresh(sessions, { selector: { status: "abandoned" } })).map((session) => session.id) : []);
       let sent = false;
       for (const registerId of registerIds) {
         const ledger = await readFresh(collection, {
@@ -5290,7 +5566,7 @@ function createRegisterOutbox(options) {
         });
         const commands = [];
         for (const command of ledger) {
-          if (command.syncStatus === "rejected" && NON_BLOCKING_REJECTIONS.has(command.error?.code ?? "")) continue;
+          if (command.syncStatus === "rejected" && isNonBlocking(command, abandoned)) continue;
           if (command.syncStatus === "rejected") break;
           commands.push(command);
           if (command.type === "register.session.open" || commands.length >= batchSize) break;
@@ -5426,6 +5702,13 @@ function createRegisterOutbox(options) {
           });
         }
       });
+      if (sessions && !sessionsSubscription) sessionsSubscription = sessions.$.subscribe((event) => {
+        if (event.documentData?.status === "abandoned") {
+          insertedDuringRun = true;
+          flush().catch(() => {
+          });
+        }
+      });
       if (!stopped) flush().catch(() => {
       });
     },
@@ -5435,6 +5718,8 @@ function createRegisterOutbox(options) {
       timer = void 0;
       subscription?.unsubscribe();
       subscription = void 0;
+      sessionsSubscription?.unsubscribe();
+      sessionsSubscription = void 0;
       missingSubscription?.unsubscribe();
       missingSubscription = void 0;
       state$.next({ ...state$.value, nextAttemptAt: void 0 });
@@ -5446,7 +5731,7 @@ function createRegisterOutbox(options) {
 import { useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
 var idle = { pending: 0, sending: false };
 function useRegisterOutbox(options) {
-  const { commands, deviceId } = options;
+  const { commands, sessions, deviceId } = options;
   const latest = useRef4(options);
   latest.current = options;
   const current = useRef4(null);
@@ -5458,6 +5743,7 @@ function useRegisterOutbox(options) {
       collection: commands,
       deviceId,
       transport: latest.current.transport(),
+      sessions: sessions ?? void 0,
       isEnabled: latest.current.isEnabled ? () => latest.current.isEnabled?.() ?? true : void 0,
       onResult: latest.current.onResult ? async (command, result) => {
         await latest.current.onResult?.(command, result);
@@ -5473,7 +5759,7 @@ function useRegisterOutbox(options) {
       current.current = null;
       setState(idle);
     };
-  }, [commands, deviceId]);
+  }, [commands, sessions, deviceId]);
   const opened = current.current;
   return {
     state: opened?.commands === commands && opened.deviceId === deviceId ? state : idle,
@@ -5606,6 +5892,148 @@ function useOrderOutbox(options) {
   };
 }
 
+// src/refund/send-order-refund.ts
+import { parseCommandResult } from "@tallyui/core/server";
+async function sendOrderRefund(transport, envelope2) {
+  let outcome;
+  try {
+    outcome = await transport.send([envelope2]);
+  } catch {
+    return { kind: "unknown", reason: "transport_error" };
+  }
+  if (outcome.kind === "retry") {
+    return {
+      kind: "unknown",
+      reason: outcome.reason,
+      ...outcome.retryAfterMs !== void 0 ? { retryAfterMs: outcome.retryAfterMs } : {}
+    };
+  }
+  if (outcome.kind === "refused" || outcome.kind === "unauthorized") return outcome;
+  const matches = outcome.results.filter((result2) => result2.id === envelope2.id);
+  if (matches.length !== 1) return { kind: "unknown", reason: "missing_result" };
+  let result;
+  try {
+    result = parseCommandResult(matches[0]);
+  } catch {
+    return { kind: "unknown", reason: "bad_result" };
+  }
+  if (result.status === "applied" || result.status === "duplicate") {
+    if (!result.refund) return { kind: "unknown", reason: "bad_result" };
+    return { kind: "applied", refund: result.refund, duplicate: result.status === "duplicate" };
+  }
+  return { kind: "rejected", error: result.error };
+}
+
+// src/refund/pos-refund.ts
+var posRefundSchema = {
+  title: "POS refunds",
+  version: 0,
+  primaryKey: "id",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: { type: "string", maxLength: 64 },
+    commandId: { type: "string", maxLength: 64 },
+    orderId: { type: "string", maxLength: 64 },
+    sessionId: { type: "string", maxLength: 64 },
+    registerId: { type: "string", maxLength: 64 },
+    envelope: { type: "object", additionalProperties: true },
+    status: { type: "string", enum: ["pending", "applied", "rejected", "unsent"], maxLength: 10 },
+    result: { type: "object", additionalProperties: true },
+    duplicate: { type: "boolean" },
+    error: { type: "object", properties: {
+      code: { type: "string" },
+      message: { type: "string" },
+      data: { type: "object", additionalProperties: true }
+    }, required: ["code", "message"], additionalProperties: false },
+    createdAt: { type: "string" },
+    updatedAt: { type: "string" }
+  },
+  required: ["id", "commandId", "orderId", "sessionId", "registerId", "envelope", "status", "createdAt", "updatedAt"],
+  indexes: [["sessionId"]]
+};
+var posRefundCollection = () => ({ schema: posRefundSchema });
+
+// src/refund/submit-order-refund.ts
+import { RxError } from "rxdb";
+var RefundAnswerPendingError = class extends Error {
+  constructor(record) {
+    super("This refund's answer is still unknown. Send it again before trying a new refund attempt.");
+    this.record = record;
+    this.name = "RefundAnswerPendingError";
+  }
+  code = "REFUND_ANSWER_PENDING";
+};
+async function submitOrderRefund({ refunds, transport, envelope: envelope2, now = () => (/* @__PURE__ */ new Date()).toISOString() }) {
+  const id2 = envelope2.payload.clientRefundId;
+  let doc = await refunds.findOne(id2).exec();
+  if (!doc) {
+    const at2 = now();
+    const { orderId, sessionId, registerId } = envelope2.payload;
+    try {
+      doc = await refunds.insert({
+        id: id2,
+        commandId: envelope2.id,
+        orderId,
+        sessionId,
+        registerId,
+        envelope: envelope2,
+        status: "pending",
+        createdAt: at2,
+        updatedAt: at2
+      });
+    } catch (error) {
+      if (!(error instanceof RxError) || error.code !== "CONFLICT") throw error;
+      doc = await refunds.findOne(id2).exec();
+    }
+  }
+  let record = doc.toJSON();
+  for (let pass = 0; ; pass++) {
+    if (pass === 2) throw new RefundAnswerPendingError(record);
+    if (record.status === "applied") {
+      return { outcome: { kind: "applied", refund: record.result, duplicate: true }, record };
+    }
+    if (record.status === "pending") {
+      if (record.commandId !== envelope2.id) throw new RefundAnswerPendingError(record);
+      break;
+    }
+    if (record.status === "rejected" && record.commandId === envelope2.id) {
+      return { outcome: { kind: "rejected", error: record.error }, record };
+    }
+    if (record.status === "unsent" && record.commandId === envelope2.id) {
+      doc = await doc.incrementalModify((stored) => {
+        if (stored.status !== "unsent" || stored.commandId !== envelope2.id) return stored;
+        const { error, ...rest } = stored;
+        return { ...rest, status: "pending", updatedAt: now() };
+      });
+      record = doc.toJSON();
+      continue;
+    }
+    doc = await doc.incrementalModify((stored) => {
+      if (stored.status !== "rejected" && stored.status !== "unsent") return stored;
+      const { result, duplicate, error, ...rest } = stored;
+      return { ...rest, commandId: envelope2.id, envelope: envelope2, status: "pending", updatedAt: now() };
+    });
+    record = doc.toJSON();
+    if (record.commandId === envelope2.id) break;
+  }
+  const outcome = await sendOrderRefund(transport, envelope2);
+  if (outcome.kind !== "unknown") {
+    doc = await doc.incrementalModify((stored) => {
+      if (stored.status !== "pending" || stored.commandId !== envelope2.id) return stored;
+      const updatedAt = now();
+      if (outcome.kind === "applied") {
+        const { error: error2, ...rest } = stored;
+        return { ...rest, status: "applied", result: outcome.refund, duplicate: outcome.duplicate, updatedAt };
+      }
+      if (outcome.kind === "rejected") return { ...stored, status: "rejected", error: outcome.error, updatedAt };
+      const error = outcome.kind === "refused" ? { code: "refused", message: outcome.reason, data: { status: outcome.status } } : { code: "unauthorized", message: "unauthorized" };
+      return { ...stored, status: "unsent", error, updatedAt };
+    });
+  }
+  return { outcome, record: doc.getLatest().toJSON() };
+}
+
 // src/tender/tender-state.ts
 var MAX_TENDER_MINOR = 999999999;
 var initialTenderState = {
@@ -5851,6 +6279,7 @@ export {
   PosOrderOpenClosedError,
   RECEIPT_SCHEMA_VERSION,
   REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS,
+  RefundAnswerPendingError,
   RegisterApprovalRequiredError,
   RegisterCloseIncompleteError,
   RegisterIdInvalidError,
@@ -5860,17 +6289,21 @@ export {
   RegisterNeedsUpgradeError,
   RegisterSessionAlreadyOpenError,
   RegisterSessionClosedError,
+  RegisterSessionConflictError,
   RegisterSessionOpenClosedError,
   RegisterSessionRequiredError,
+  RegisterTakeOverError,
   RegisterTenderInProgressError,
   SALE_SAVING,
   TAX_ROUNDING_MIXED_NOTE,
   TaxProvider,
   UnsupportedOrderVersionError,
+  abandonSession,
   activePlan,
   addEntryToCart,
   addPosOrderCollection,
   addRegisterSessionCollection,
+  adoptRegisterResults,
   advancePerpetual,
   allocateOrderDiscount,
   appliedMinor,
@@ -5942,6 +6375,8 @@ export {
   posOrderCollection,
   posOrderSchema,
   posOrdersLogger,
+  posRefundCollection,
+  posRefundSchema,
   productCategories,
   productSortValue,
   quickTenderedAmounts,
@@ -5968,6 +6403,7 @@ export {
   sameSale,
   searchProducts,
   selectClosureRows,
+  sendOrderRefund,
   sessionOpenCommand,
   sessionTransitionCommand,
   sortProducts,
@@ -5975,6 +6411,8 @@ export {
   startCounting,
   stockOverlay$,
   stockOverlayAsOf$,
+  submitOrderRefund,
+  takeOverSession,
   taxFiguresForBasket,
   taxLinesByRate,
   taxLogger,