@tallyui/pos 3.5.3 → 3.7.0

package/dist/index.js

@@ -1364,6 +1364,9 @@ function useParkedSales(drafts) {
   return { parked, discard };
 }
 
+// src/receipt/types.ts
+var RECEIPT_SCHEMA_VERSION = "1.4.0";
+
 // src/receipt/build-receipt-data.ts
 function buildReceiptData(order, config) {
   const taxedLines = [...order.lineItems.map((line) => order.taxRounding?.granularity === "woocommerce" && line.netMicros !== void 0 ? { ...line, taxInclusive: order.pricesIncludeTax } : line), ...[...order.fees ?? [], ...order.shipping ?? []].map((charge) => ({
@@ -1387,6 +1390,23 @@ function buildReceiptData(order, config) {
   const label = (d) => d.label ?? d.couponCode ?? `${d.type} discount`;
   const customer = order.customer?.name || order.customer?.email;
   return {
+    schemaVersion: RECEIPT_SCHEMA_VERSION,
+    software: {
+      name: "WCPOS",
+      plugin_version: "",
+      app_version: "",
+      app_build: "",
+      platform: "",
+      ...config.software
+    },
+    register: { id: config.register ?? "", name: config.registerName ?? "" },
+    fiscal: {
+      document_type: "sale",
+      is_reprint: false,
+      reprint_count: 0,
+      qr_payload: "",
+      ...config.fiscal
+    },
     header: {
       storeName: config.storeName,
       storeAddress: config.storeAddress,
@@ -2101,7 +2121,7 @@ function posOrderCollection() {
   };
 }
 
-// src/pos-order/open.ts
+// src/rxdb/open-migrated-collection.ts
 import {
   deepEqual,
   defaultConflictHandler,
@@ -2115,16 +2135,6 @@ import {
 } 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) {
@@ -2137,35 +2147,40 @@ function waitWithTimeout(promise, ms) {
   });
 }
 async function writeOverStaleCopies(collection, from, to, stopIfClosing) {
+  const primaryKey = collection.schema.primaryPath;
   const handler = rxStorageInstanceToReplicationHandler(to, defaultConflictHandler, collection.database.token, true);
   for (let page = await getChangedDocumentsSince(from, 200); page.documents.length > 0; page = await getChangedDocumentsSince(from, 200, page.checkpoint)) {
     stopIfClosing();
-    const copies = new Map((await to.findDocumentsById(page.documents.map((doc) => doc.id), false)).map((copy) => [copy.id, copy]));
-    const rows = await Promise.all(page.documents.filter((doc) => copies.has(doc.id) && !doc._deleted).map(async (doc) => ({ assumedMasterState: copies.get(doc.id), newDocumentState: await migrateDocumentData(collection, from.schema.version, doc) })));
+    const copies = new Map((await to.findDocumentsById(page.documents.map((doc) => doc[primaryKey]), false)).map((copy) => [copy[primaryKey], copy]));
+    const rows = await Promise.all(page.documents.filter((doc) => copies.has(doc[primaryKey]) && !doc._deleted).map(async (doc) => ({ assumedMasterState: copies.get(doc[primaryKey]), 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);
+async function openMigratedCollection(db, opener, closeWaitMs) {
+  const { name, label, closedError } = opener;
+  if (db.multiInstance) throw new Error(`${label}: multiInstance databases are not supported (ADR-061)`);
+  if (db.closed || db.closePromise) throw closedError(db.name);
+  const opens = latestOpens.get(db) ?? /* @__PURE__ */ new Map();
+  latestOpens.set(db, opens);
+  const previous = opens.get(name);
   if (!previous) {
-    db.onClose.push(() => waitWithTimeout(latestOpens.get(db), closeWaitMs).then((settled) => {
+    db.onClose.push(() => waitWithTimeout(latestOpens.get(db).get(name), closeWaitMs).then((settled) => {
       if (!settled) closedUnderOpen.add(db);
     }));
   }
-  const opening = openPosOrders(db, previous);
-  latestOpens.set(db, Promise.all([previous, opening.catch(() => void 0)]));
+  const opening = openCollection(db, opener, previous);
+  opens.set(name, Promise.all([previous, opening.catch(() => void 0)]));
   return opening;
 }
-async function openPosOrders(db, previous) {
+async function openCollection(db, opener, previous) {
+  const { name, creator, logger, closedError } = opener;
   let cancelled = false;
   const closing = () => cancelled || closedUnderOpen.has(db) || db.closed;
   const stopIfClosing = () => {
-    if (closing()) throw new PosOrderOpenClosedError(db.name);
+    if (closing()) throw closedError(db.name);
   };
-  const { pos_orders: collection } = await db.addCollections({ pos_orders: { ...posOrderCollection(), autoMigrate: false } });
+  const { [name]: collection } = await db.addCollections({ [name]: { ...creator(), autoMigrate: false } });
   const state = collection.getMigrationState();
   try {
     stopIfClosing();
@@ -2188,7 +2203,7 @@ async function openPosOrders(db, previous) {
     stopIfClosing();
     const checkpoint = await db.storage.createStorageInstance({
       databaseName: db.name,
-      collectionName: `rx-migration-state-meta-pos_orders-${old.version}`,
+      collectionName: `rx-migration-state-meta-${name}-${old.version}`,
       databaseInstanceToken: db.token,
       multiInstance: db.multiInstance,
       options: {},
@@ -2214,7 +2229,7 @@ async function openPosOrders(db, previous) {
     } });
     const internalStore = gate(db.internalStore, async (key, first) => {
       const ids = key === "bulkWrite" ? first.map((row) => row.document.id) : first;
-      posOrdersLogger.warn(
+      logger.warn(
         `The database closed during the migration: dropped a ${key === "bulkWrite" ? "status write" : "status read"}`,
         { database: db.name, ids }
       );
@@ -2224,7 +2239,7 @@ async function openPosOrders(db, previous) {
     const migrateStorage = state.migrateStorage.bind(state);
     state.migrateStorage = async (from, current, batchSize) => {
       stopIfClosing();
-      const to = gate(current, () => Promise.reject(new PosOrderOpenClosedError(db.name)));
+      const to = gate(current, () => Promise.reject(closedError(db.name)));
       if (from.collectionName === collection.name) await writeOverStaleCopies(collection, from, to, stopIfClosing);
       stopIfClosing();
       return migrateStorage(new Proxy(from, { get: (target, key) => {
@@ -2259,8 +2274,29 @@ async function openPosOrders(db, previous) {
     throw newRxError("DM4", { collection: collection.name, error: status?.error });
   } catch (error) {
     await collection.close();
-    throw closing() ? new PosOrderOpenClosedError(db.name) : error;
+    throw closing() ? closedError(db.name) : error;
+  }
+}
+
+// src/pos-order/open.ts
+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";
+};
+function addPosOrderCollection(db, closeWaitMs = POS_ORDER_MIGRATION_CLOSE_WAIT_MS) {
+  return openMigratedCollection(db, {
+    name: "pos_orders",
+    creator: posOrderCollection,
+    label: "addPosOrderCollection",
+    logger: posOrdersLogger,
+    closedError: (name) => new PosOrderOpenClosedError(name)
+  }, closeWaitMs);
 }
 
 // src/pos-order/device-id.ts
@@ -2282,7 +2318,7 @@ function getDeviceId(storage, key) {
 // src/pos-order/needs-attention.ts
 import { knownWarnings } from "@tallyui/core";
 function needsAttention(orders, options = {}) {
-  return orders.filter((order) => order.syncStatus === "rejected" || (order.localWarnings?.length ?? 0) > 0 || order.syncStatus === "applied" && knownWarnings(order.warnings).length > 0 || order.lateSessionId !== void 0 || order.syncStatus === "pending" && options.stuckCommandIds?.includes(order.commandId) === true).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  return orders.filter((order) => order.syncStatus === "rejected" || (order.localWarnings?.length ?? 0) > 0 || order.syncStatus === "applied" && knownWarnings(order.warnings).some((warning) => warning.code !== "register_session_unknown") || order.lateSessionId !== void 0 || order.syncStatus === "pending" && options.stuckCommandIds?.includes(order.commandId) === true).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }
 
 // src/pos-order/same-sale.ts
@@ -2375,6 +2411,7 @@ var denominations = {
 // src/register/schemas.ts
 import { addRxPlugin as addRxPlugin2 } from "rxdb";
 import { RxDBLocalDocumentsPlugin } from "rxdb/plugins/local-documents";
+import { RxDBMigrationSchemaPlugin as RxDBMigrationSchemaPlugin2 } from "rxdb/plugins/migration-schema";
 var id = { type: "string", maxLength: 36 };
 var text = { type: "string" };
 var nullableText = { type: ["string", "null"] };
@@ -2383,7 +2420,7 @@ var nullableMinor = { type: ["integer", "null"] };
 var tenders = { type: "object", additionalProperties: minor };
 var registerSessionSchema = {
   title: "Register sessions",
-  version: 0,
+  version: 1,
   primaryKey: "id",
   type: "object",
   additionalProperties: false,
@@ -2391,7 +2428,8 @@ var registerSessionSchema = {
     id,
     register_id: id,
     store_key: nullableText,
-    status: { type: "string", enum: ["open", "counting", "closed"], maxLength: 8 },
+    status: { type: "string", maxLength: 20 },
+    server_session_id: { ...nullableText, default: null },
     business_day: { type: "string", maxLength: 10 },
     opened_at_gmt: text,
     opened_by: nullableText,
@@ -2415,9 +2453,16 @@ var registerSessionSchema = {
   required: ["id", "register_id", "status", "opened_at_gmt", "counted_float_minor"],
   indexes: [["register_id", "status"]]
 };
-function registerSessionCollection() {
+function registerSessionCreator() {
   addRxPlugin2(RxDBLocalDocumentsPlugin);
-  return { schema: registerSessionSchema, localDocuments: true };
+  addRxPlugin2(RxDBMigrationSchemaPlugin2);
+  return { schema: registerSessionSchema, localDocuments: true, migrationStrategies: { 1: (doc) => {
+    doc.server_session_id ??= null;
+    return doc;
+  } } };
+}
+function registerSessionCollection() {
+  throw new Error("registerSessionCollection() is gone: open register_sessions with await addRegisterSessionCollection(db). Adding it with addCollections would run RxDB's own migration of schema version 1, which can lose sessions (ADR-078, #371).");
 }
 var cashMovementSchema = {
   title: "Cash movements",
@@ -2501,6 +2546,27 @@ var closureSchema = {
   indexes: [["register_id"], ["session_id"]]
 };
 
+// src/register/open.ts
+var registerSessionsLogger = createLogger("register-sessions");
+var REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS = 1e4;
+var RegisterSessionOpenClosedError = class extends Error {
+  constructor(databaseName) {
+    super(`addRegisterSessionCollection: database ${databaseName} closed during the open; reopen it and open register_sessions again`);
+    this.databaseName = databaseName;
+    this.name = "RegisterSessionOpenClosedError";
+  }
+  code = "REGISTER_SESSION_OPEN_CLOSED";
+};
+function addRegisterSessionCollection(db, closeWaitMs = REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS) {
+  return openMigratedCollection(db, {
+    name: "register_sessions",
+    creator: registerSessionCreator,
+    label: "addRegisterSessionCollection",
+    logger: registerSessionsLogger,
+    closedError: (name) => new RegisterSessionOpenClosedError(name)
+  }, closeWaitMs);
+}
+
 // src/register/register-document.ts
 import { map as map4 } from "rxjs";
 var REGISTER = "register";
@@ -2740,6 +2806,13 @@ var RegisterSessionClosedError = class extends Error {
     this.name = "RegisterSessionClosedError";
   }
 };
+var RegisterNeedsUpgradeError = class extends Error {
+  code = "REGISTER_NEEDS_UPGRADE";
+  constructor() {
+    super("This till has register data from a newer version of the app. Update the app to continue.");
+    this.name = "RegisterNeedsUpgradeError";
+  }
+};
 var RegisterMovementAmountError = class extends Error {
   constructor(type, amountMinor) {
     super(`movement_amount_invalid:${type}:${amountMinor}`);
@@ -2765,8 +2838,13 @@ var RegisterMovementStrandedError = class extends Error {
 var TRANSITIONS = {
   open: ["counting", "closed"],
   counting: ["open", "closed"],
-  closed: []
+  closed: [],
+  conflict: [],
+  superseded: []
 };
+function isKnownSessionStatus(status) {
+  return Object.hasOwn(TRANSITIONS, status);
+}
 async function readSession(sessions, id2) {
   const [stored] = await sessions.storageInstance.findDocumentsById([id2], false);
   return stored;
@@ -2778,6 +2856,7 @@ async function readClosure(closures, id2) {
 async function requireLiveSession(sessions, id2) {
   const session = await readSession(sessions, id2);
   if (!session) throw new RegisterSessionRequiredError();
+  if (!isKnownSessionStatus(session.status)) throw new RegisterNeedsUpgradeError();
   if (session.status === "closed") throw new RegisterSessionClosedError();
   return session;
 }
@@ -2855,6 +2934,7 @@ async function transition(sessions, id2, status, extra = {}) {
   if (row.status === "closed" && status === "closed") return row;
   const at2 = (/* @__PURE__ */ new Date()).toISOString();
   return row.incrementalModify((doc) => {
+    if (!isKnownSessionStatus(doc.status)) throw new RegisterNeedsUpgradeError();
     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}`);
@@ -3591,6 +3671,7 @@ function closureCommand(c) {
 }
 var chains = /* @__PURE__ */ new WeakMap();
 function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed }) {
+  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());
   const run = (registers.get(registerId) ?? Promise.resolve()).then(async () => {
@@ -3605,12 +3686,12 @@ function reconcileRegisterCommands({ commands, sessions, movements, closures, ho
         readFresh(movements, { selector: { session_id: session.id } }),
         session.closure_id ? closures.storageInstance.findDocumentsById([session.closure_id], false) : Promise.resolve([])
       ]);
-      const events = (observed ?? []).filter((row) => row.id === session.id && !transitioned.has(session.id) && row.status !== session.status && row.status !== "closed").flatMap((row) => row.status_at == null ? [] : [sessionTransitionCommand({ ...row, status_at: row.status_at })]);
+      const events = (observed ?? []).filter((row) => row.id === session.id && !transitioned.has(session.id) && row.status !== session.status && row.status !== "closed").flatMap((row) => row.status_at == null || !sentStatus(row) ? [] : [sessionTransitionCommand({ ...row, status_at: row.status_at })]);
       events.push(
         ...entries.filter((entry) => entry.type !== "void").map(movementCommand),
         ...entries.filter((entry) => entry.type === "void").map(movementCommand)
       );
-      if (session.status_at != null) events.push(sessionTransitionCommand({ ...session, status_at: session.status_at }));
+      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),
         ...events,
@@ -3679,6 +3760,7 @@ 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) {
+  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;
 }
 function ledgerRows(orders) {
@@ -3805,6 +3887,8 @@ function useRegisterSession(options) {
   const nameOf = (id2) => !id2 ? "" : id2 === actor.id ? actor.name : labels?.resolveCashierName?.(id2) ?? "";
   return {
     session,
+    /** Any unknown session status in the current snapshot means the register needs upgrade. */
+    needsUpgrade: data?.rows.some((row) => !isKnownSessionStatus(row.status)) ?? false,
     movements: entries,
     expected,
     salesCount: sales.length,
@@ -3827,6 +3911,7 @@ function useRegisterSession(options) {
        * 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`.
        */
       openSession: async (input) => {
         const key = registerId ?? "";
@@ -3834,6 +3919,7 @@ function useRegisterSession(options) {
         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) => !isKnownSessionStatus(row2.status))) throw new RegisterNeedsUpgradeError();
           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);
@@ -5086,6 +5172,7 @@ function createOrderOutbox(options) {
 
 // src/outbox/register-outbox.ts
 import { BehaviorSubject as BehaviorSubject5 } from "rxjs";
+var NON_BLOCKING_REJECTIONS = /* @__PURE__ */ new Set(["register_session_superseded", "register_session_abandoned"]);
 function plainCommand({
   key,
   registerId,
@@ -5165,8 +5252,9 @@ function createRegisterOutbox(options) {
       selector: { syncStatus: { $in: ["pending", "rejected"] } },
       sort: [{ seq: "asc" }, { key: "asc" }]
     })) {
-      if (command.syncStatus === "rejected") blocked.add(command.registerId);
-      else if (!blocked.has(command.registerId)) sendable2.add(command.commandId);
+      if (command.syncStatus === "rejected") {
+        if (!NON_BLOCKING_REJECTIONS.has(command.error?.code ?? "")) blocked.add(command.registerId);
+      } else if (!blocked.has(command.registerId)) sendable2.add(command.commandId);
     }
     for (const id2 of clocks.keys()) if (!sendable2.has(id2)) clocks.delete(id2);
     state$.next({ ...state$.value, ...patch, pending, stuck: stuckState() });
@@ -5202,9 +5290,10 @@ 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") break;
           commands.push(command);
-          if (commands.length >= batchSize) break;
+          if (command.type === "register.session.open" || commands.length >= batchSize) break;
         }
         if (stopped) {
           stoppedDuringRun = true;
@@ -5707,6 +5796,49 @@ function planLegs(plan, rowsSinceFrom, balanceMinor) {
   const title = plan.kind === "fixed" && taken === 0 ? plan.title : null;
   return { legs, thisPaymentMinor: each, label: { n: taken + 1, ways, rest, title } };
 }
+
+// src/tender/tender-void.ts
+var tenderVoidSchema = {
+  title: "Tender voids",
+  version: 0,
+  primaryKey: "paymentId",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    paymentId: { type: "string", maxLength: 64 },
+    saleId: { type: "string", maxLength: 64 },
+    type: { type: "string", enum: ["void"], maxLength: 4 },
+    // Not an enum: PaymentMethodKind grows, and a stored enum would need a schema migration per new kind.
+    method: { type: "string", maxLength: 32 },
+    amountMinor: { type: "integer" },
+    tenderedMinor: { type: "integer" },
+    reference: { type: "string" },
+    currency: { type: "string", maxLength: 3 },
+    reason: { type: "string", enum: ["removed", "cancelled"] },
+    deviceTime: { type: "string", maxLength: 40 },
+    deviceTz: { type: "string" },
+    registerId: { type: "string" },
+    sessionId: { type: "string" },
+    cashierRef: { type: "string" }
+  },
+  required: [
+    "paymentId",
+    "saleId",
+    "type",
+    "method",
+    "amountMinor",
+    "currency",
+    "reason",
+    "deviceTime",
+    "deviceTz",
+    "registerId",
+    "cashierRef"
+  ],
+  indexes: [["saleId"], ["deviceTime"]]
+};
+function tenderVoidCollection() {
+  return { schema: tenderVoidSchema };
+}
 export {
   CartError,
   CurrencyProvider,
@@ -5717,14 +5849,18 @@ export {
   OrderContentMismatchError,
   PRODUCT_SORT_FIELDS,
   PosOrderOpenClosedError,
+  RECEIPT_SCHEMA_VERSION,
+  REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS,
   RegisterApprovalRequiredError,
   RegisterCloseIncompleteError,
   RegisterIdInvalidError,
   RegisterMovementAmountError,
   RegisterMovementReasonError,
   RegisterMovementStrandedError,
+  RegisterNeedsUpgradeError,
   RegisterSessionAlreadyOpenError,
   RegisterSessionClosedError,
+  RegisterSessionOpenClosedError,
   RegisterSessionRequiredError,
   RegisterTenderInProgressError,
   SALE_SAVING,
@@ -5734,6 +5870,7 @@ export {
   activePlan,
   addEntryToCart,
   addPosOrderCollection,
+  addRegisterSessionCollection,
   advancePerpetual,
   allocateOrderDiscount,
   appliedMinor,
@@ -5780,6 +5917,7 @@ export {
   inCategory,
   initTenderState,
   initialTenderState,
+  isKnownSessionStatus,
   isServerDecimal,
   labelKeys,
   listCategories,
@@ -5820,6 +5958,7 @@ export {
   registerFactsLogger,
   registerSessionCollection,
   registerSessionSchema,
+  registerSessionsLogger,
   requireOpenSession,
   resolveGridColumns,
   resolveStoreSettings,
@@ -5842,6 +5981,8 @@ export {
   taxMicros,
   taxProviderProps,
   tenderReducer,
+  tenderVoidCollection,
+  tenderVoidSchema,
   toOrderCreateEnvelope,
   unbindRegister,
   useCurrencyCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyui/pos",
-  "version": "3.5.3",
+  "version": "3.7.0",
   "type": "module",
   "description": "Shared POS business logic for Tally UI — tax, orders, payments, discounts, receipts",
   "main": "./dist/index.js",
@@ -27,20 +27,20 @@
     "directory": "packages/pos"
   },
   "peerDependencies": {
-    "@tallyui/core": "^3.5.3",
+    "@tallyui/core": "^3.7.0",
     "react": ">=18",
     "rxdb": "~17.5.0",
     "rxjs": ">=7"
   },
   "devDependencies": {
-    "@tallyui/core": "3.5.3",
+    "@tallyui/core": "3.7.0",
     "@types/react": ">=18",
     "react": "^19.2.4",
     "rxdb": "17.5.0",
     "rxjs": "7.8.2",
-    "@tallyui/connector-medusa": "3.5.3",
-    "@tallyui/connector-woocommerce": "3.5.3",
-    "@tallyui/database": "3.5.3"
+    "@tallyui/connector-medusa": "3.7.0",
+    "@tallyui/connector-woocommerce": "3.7.0",
+    "@tallyui/database": "3.7.0"
   },
   "scripts": {
     "build": "tsup",

package/src/index.ts

@@ -51,8 +51,8 @@ export type {
 } from './order';
 
 // Receipt
-export { buildReceiptData } from './receipt';
-export type { ReceiptData, ReceiptLineItem, ReceiptConfig } from './receipt';
+export { buildReceiptData, RECEIPT_SCHEMA_VERSION } from './receipt';
+export type { ReceiptData, ReceiptLineItem, ReceiptConfig, ReceiptSoftware, ReceiptRegister, ReceiptFiscal } from './receipt';
 
 // Product
 export { searchProducts, sortProducts, productSortValue, PRODUCT_SORT_FIELDS, type ProductSort, type ProductSortValue, catalogueViewReducer, normalizeCatalogueViewState, resolveGridColumns, DEFAULT_CATALOGUE_VIEW_STATE, type CatalogueView, type CatalogueGridColumns, type CatalogueViewState, type CatalogueViewAction, withStockOverlay, getProductStock, stockOverlay$, stockOverlayAsOf$, productCategories, listCategories, inCategory } from './product';
@@ -69,19 +69,20 @@ export type { RegisterOutboxOptions, RegisterOutbox, UseRegisterOutboxOptions, U
 export { createBackendNotFound } from './outbox/backend-not-found';
 export type { BackendNotFound } from './outbox/backend-not-found';
 export type { HttpTransportOptions, OrderOutboxOptions, OrderOutbox, TransportOutcome, CommandTransport, OrderTransportContext, OutboxState, UseOrderOutboxOptions, UseOrderOutboxResult } from './outbox';
-export { tenderReducer, initTenderState, initialTenderState, appliedMinor, changeMinor, quickTenderedAmounts, evenSplitShareMinor, activePlan, planLegs, MAX_TENDER_MINOR } from './tender';
-export type { PaymentTransport, TenderView, TenderLineId, TenderPlan, SplitTab, TenderState, TenderKey, TenderAction, PlanLeg } from './tender';
+export { tenderReducer, initTenderState, initialTenderState, appliedMinor, changeMinor, quickTenderedAmounts, evenSplitShareMinor, activePlan, planLegs, MAX_TENDER_MINOR, tenderVoidSchema, tenderVoidCollection } from './tender';
+export type { PaymentTransport, TenderView, TenderLineId, TenderPlan, SplitTab, TenderState, TenderKey, TenderAction, PlanLeg, TenderVoid } from './tender';
 
 // Register
 export { normalizeAmount, isServerDecimal, movementFieldError, deriveExpected, parseMinor, validAmount, countVariance, overThreshold, closeNeedsApproval, denominationTotal, varianceText, denominations } from './register';
 export type { MovementType, LedgerRow, Movement } from './register';
 export { registerSessionSchema, registerSessionCollection, cashMovementSchema, closureSchema } from './register';
+export { addRegisterSessionCollection, RegisterSessionOpenClosedError, registerSessionsLogger, REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS } from './register';
 export type { RegisterSession, CashMovement, Closure } from './register';
 export { registerCommandSchema, registerCommandCollection, registerCommandsLogger, sessionOpenCommand, sessionTransitionCommand, movementCommand, closureCommand, reconcileRegisterCommands } from './register';
 export type { RegisterCommand, RegisterCommandCollection } from './register';
 export { mintUuid, readRegister, ensureRegister, observeRegister$, getBoundRegisterId, readBoundRegister, bindRegister, unbindRegister, nextSaleCounter, mintClosureNumber, advancePerpetual, RegisterIdInvalidError } from './register';
 export type { RegisterHost, RegisterCounters, RegisterBucket, RegisterStore, RegisterDocument } from './register';
-export { RegisterSessionRequiredError, RegisterSessionClosedError, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, openSessionSelector, requireOpenSession, stampSession, openSession, startCounting, backToSelling, closeSession, recordMovement, voidMovement, writeClosure } from './register';
+export { RegisterSessionRequiredError, RegisterSessionClosedError, RegisterNeedsUpgradeError, isKnownSessionStatus, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, openSessionSelector, requireOpenSession, stampSession, openSession, startCounting, backToSelling, closeSession, recordMovement, voidMovement, writeClosure } from './register';
 export type { RegisterSessionCollection, CashMovementCollection, ClosureCollection } from './register';
 export { deriveSettled, exportCsv, labelKeys, clampClosureScope, selectClosureRows } from './register';
 export type { Correction, RecordedFigures, ClosureScope } from './register';

package/src/outbox/register-outbox.ts

@@ -7,6 +7,9 @@ import { createBackendNotFound, type BackendNotFound } from './backend-not-found
 import { STUCK_AFTER_MS } from './order-outbox';
 import type { CommandTransport, OutboxState } from './types';
 
+/** Final rejections that do not stop their register's ledger (ADR-078): the commands behind them are still sent. */
+export const NON_BLOCKING_REJECTIONS: ReadonlySet<string> = new Set(['register_session_superseded', 'register_session_abandoned']);
+
 export interface RegisterOutboxOptions {
   collection: RxCollection<RegisterCommand>;
   transport: CommandTransport<RegisterCommandEnvelope>;
@@ -68,7 +71,7 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
   // like a 503, or `no_progress`); a running clock keeps its `since` and takes the latest reason. A `network` failure
   // pauses every clock (`pausedAt`), and the next answer of any kind resumes them, moving `since` on by the offline
   // gap, so `since` is now minus the answered time. A clock clears when its command is no longer pending under its
-  // commandId (applied or rejected), or when a rejected command comes ahead of it in its ledger (it is not being
+  // commandId (applied or rejected), or when a blocking rejected command comes ahead of it in its ledger (it is not being
   // sent: Front desk, 2026-09-30); commands never sent have none. Nothing is isolated: a stuck command at the head
   // of a register's ledger holds up the commands behind it, by design, since register facts apply in `seq` order.
   // In memory only: a restart starts with no clocks, and the first answered failure after it starts them afresh
@@ -96,8 +99,9 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
     const blocked = new Set<string>();
     if (clocks.size) for (const command of await readFresh(collection, { selector: { syncStatus: { $in: ['pending', 'rejected'] } },
       sort: [{ seq: 'asc' }, { key: 'asc' }] })) {
-      if (command.syncStatus === 'rejected') blocked.add(command.registerId);
-      else if (!blocked.has(command.registerId)) sendable.add(command.commandId);
+      if (command.syncStatus === 'rejected') {
+        if (!NON_BLOCKING_REJECTIONS.has(command.error?.code ?? '')) blocked.add(command.registerId);
+      } else if (!blocked.has(command.registerId)) sendable.add(command.commandId);
     }
     for (const id of clocks.keys()) if (!sendable.has(id)) clocks.delete(id);
     state$.next({ ...state$.value, ...patch, pending, stuck: stuckState() });
@@ -127,9 +131,10 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
         });
         const commands: RegisterCommand[] = [];
         for (const command of ledger) {
+          if (command.syncStatus === 'rejected' && NON_BLOCKING_REJECTIONS.has(command.error?.code ?? '')) continue;
           if (command.syncStatus === 'rejected') break;
           commands.push(command);
-          if (commands.length >= batchSize) break;
+          if (command.type === 'register.session.open' || commands.length >= batchSize) break;
         }
         if (stopped) { stoppedDuringRun = true; return; }
         if (!commands.length) continue;

package/src/pos-order/needs-attention.ts

@@ -6,11 +6,12 @@ import type { PosOrder } from './types';
  * session closed (`lateSessionId`) or with local warnings (whatever the sync status), or pending with a `commandId` in
  * `stuckCommandIds` (the outbox's `OutboxState.stuck`: the store keeps failing it), newest first.
  * A warning code this till version doesn't know is not shown here (`knownWarnings`). Never changes `orders`.
+ * `register_session_unknown` is not shown, because the store counts the order once its session arrives (ADR-078).
  */
 export function needsAttention(orders: PosOrder[], options: { stuckCommandIds?: readonly string[] } = {}): PosOrder[] {
   return orders.filter((order) => order.syncStatus === 'rejected'
     || (order.localWarnings?.length ?? 0) > 0
-    || (order.syncStatus === 'applied' && knownWarnings(order.warnings).length > 0) || order.lateSessionId !== undefined
+    || (order.syncStatus === 'applied' && knownWarnings(order.warnings).some((warning) => warning.code !== 'register_session_unknown')) || order.lateSessionId !== undefined
     || (order.syncStatus === 'pending' && options.stuckCommandIds?.includes(order.commandId) === true))
     .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }