@tallyui/pos 3.7.0 → 3.8.0

package/dist/index.d.ts

@@ -1074,8 +1074,8 @@ interface RegisterSession {
     register_id: string;
     /** The app's neutral store key (see `bindRegister`). */
     store_key?: string | null;
-    /** Stored status is an open string so a later local state costs no migration (ADR-078 decision 9); the union names today's states. */
-    status: 'open' | 'counting' | 'closed' | 'conflict' | 'superseded';
+    /** Stored status is an open string so a later local state costs no migration (ADR-078 decision 9); the union names today's states. `abandoned` is local only and terminal (the cashier chose another register while in conflict). */
+    status: 'open' | 'counting' | 'closed' | 'conflict' | 'superseded' | 'abandoned';
     /** The store session this local id was resumed as (ADR-078 decision 2), never the session that superseded it; null until a resume. */
     server_session_id?: string | null;
     /** The store's day the session opened, `yyyy-MM-dd`. */
@@ -1261,6 +1261,15 @@ declare class RegisterNeedsUpgradeError extends Error {
     readonly code = "REGISTER_NEEDS_UPGRADE";
     constructor();
 }
+/** Opening is refused while the register has a `conflict` session (ADR-078); its message can be shown to a cashier as it is. */
+declare class RegisterSessionConflictError extends Error {
+    readonly code = "REGISTER_SESSION_CONFLICT";
+    constructor();
+}
+declare class RegisterTakeOverError extends Error {
+    readonly code: 'REGISTER_TAKEOVER_UNSUPPORTED' | 'REGISTER_TAKEOVER_PENDING';
+    constructor(code: 'REGISTER_TAKEOVER_UNSUPPORTED' | 'REGISTER_TAKEOVER_PENDING');
+}
 /** ADR-068 6a: movement amounts must be safe integers, positive for paid_in/paid_out and zero for no_sale. */
 declare class RegisterMovementAmountError extends Error {
     constructor(type: 'paid_in' | 'paid_out' | 'no_sale', amountMinor: number);
@@ -1840,9 +1849,11 @@ declare const registerCommandCollection: () => {
     schema: RxJsonSchema<RegisterCommand>;
 };
 type BuiltCommand = Pick<RegisterCommand, 'key' | 'type' | 'payload'> & {
-    version: 1;
+    version: 1 | 2;
 };
-declare function sessionOpenCommand(s: RegisterSession): BuiltCommand;
+declare function sessionOpenCommand(s: RegisterSession, v2?: {
+    deviceName?: string | null;
+}): BuiltCommand;
 declare function sessionTransitionCommand(s: RegisterSession & {
     status: RegisterSessionTransitionPayload['status'];
     status_at: string;
@@ -1850,7 +1861,7 @@ declare function sessionTransitionCommand(s: RegisterSession & {
 declare function movementCommand(m: CashMovement): BuiltCommand;
 declare function closureCommand(c: Closure): BuiltCommand;
 /** Appends missing facts in dependency order; the bytes of an existing key never change. */
-declare function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed }: {
+declare function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed, registerContract, deviceName }: {
     commands: RegisterCommandCollection;
     sessions: RegisterSessionCollection;
     movements: CashMovementCollection;
@@ -1860,6 +1871,8 @@ declare function reconcileRegisterCommands({ commands, sessions, movements, clos
     registerId: string;
     now?: string;
     observed?: RegisterSession[];
+    registerContract?: number;
+    deviceName?: string | null;
 }): Promise<string[]>;
 
 /** A sale is at tender, so the till can't count or close under it. Its message can be shown to a cashier as it is. */
@@ -1888,6 +1901,8 @@ interface UseRegisterSessionOptions {
     /** `register_commands`, created with `registerCommandCollection()`; `null` while it opens. */
     commands?: RegisterCommandCollection | null;
     capabilities?: ServerCapabilities;
+    /** The till's name from the app's settings, sent on a register v2 open; the app supplies its platform fallback. */
+    deviceName?: string | null;
     /** `pos_orders`: a session's sales are those whose `sessionId` is its id. */
     orders: RxCollection<PosOrder> | null;
     /** The register document's host, for the closure number and perpetual totals (`writeClosure`); `null` while it opens. */
@@ -1920,6 +1935,20 @@ interface UseRegisterSessionOptions {
 }
 declare function useRegisterSession(options: UseRegisterSessionOptions): {
     session: RegisterSession | null;
+    /** The other till's live session, or the session this till is waiting to take over. */
+    conflict: {
+        sessionId: string;
+        takingOver: boolean;
+        openedAt?: undefined;
+        openedBy?: undefined;
+        deviceName?: undefined;
+    } | {
+        sessionId: string;
+        openedAt: string | undefined;
+        openedBy: string | undefined;
+        deviceName: string | undefined;
+        takingOver: boolean;
+    } | undefined;
     /** Any unknown session status in the current snapshot means the register needs upgrade. */
     needsUpgrade: boolean;
     movements: CashMovement[];
@@ -1946,11 +1975,14 @@ declare function useRegisterSession(options: UseRegisterSessionOptions): {
         sessions: RegisterSessionCollection;
     } | null>;
     actions: {
+        takeOver: () => Promise<void>;
+        chooseAnotherRegister: () => Promise<void>;
         /**
          * 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: (input: {
             expectedFloatMinor: number | null;
@@ -1982,6 +2014,25 @@ declare function useRegisterSession(options: UseRegisterSessionOptions): {
     };
 };
 
+/**
+ * Applied opens fill a missing resume id; refused opens make open/counting sessions conflict.
+ * Superseded rejections make open/counting sessions terminal; a conflict session leaves only by an applied open or abandon (ADR-078 decision 9); terminal/unknown states stay untouched.
+ * Applied conflict opens restore the latest transition's counting state, otherwise open; pending rows do nothing.
+ * Answers are walked in seq/key order; adoption is idempotent and safe to run at any time.
+ */
+declare function adoptRegisterResults({ commands, sessions, registerId }: {
+    commands: RegisterCommandCollection;
+    sessions: RegisterSessionCollection;
+    registerId: string;
+}): Promise<void>;
+declare function takeOverSession({ commands, sessions, sessionId, now }: {
+    commands: RegisterCommandCollection;
+    sessions: RegisterSessionCollection;
+    sessionId: string;
+    now?: string;
+}): Promise<void>;
+declare function abandonSession(input: Parameters<typeof takeOverSession>[0]): Promise<void>;
+
 type CatalogueEntry<Doc> = {
     product: Doc;
     variant: VariantSummary;
@@ -2287,6 +2338,9 @@ declare function createOrderOutbox(options: OrderOutboxOptions): OrderOutbox;
 
 interface RegisterOutboxOptions {
     collection: RxCollection<RegisterCommand>;
+    /** The till's `register_sessions`. With it, a refused open (`register_session_already_open`) stops blocking its register
+     * once its session is `abandoned` (ADR-078 decision 9). Without it, that refusal always blocks. */
+    sessions?: RegisterSessionCollection;
     transport: CommandTransport<RegisterCommandEnvelope>;
     deviceId: string;
     /** Checked at the start of every run; false sends nothing. */
@@ -2314,6 +2368,8 @@ declare function createRegisterOutbox(options: RegisterOutboxOptions): RegisterO
 interface UseRegisterOutboxOptions {
     /** `register_commands` (see `registerCommandCollection()`); `null` while it opens or when there's no store. A new collection (a store switch) restarts the outbox. */
     commands: RegisterCommandCollection | null;
+    /** The till's `register_sessions`; abandoned sessions unblock refused opens. A new collection restarts the outbox. */
+    sessions?: RegisterSessionCollection | null;
     /** Builds the transport; called when the outbox is created: on each new collection or device id (twice under React StrictMode's double effect, which stops the first outbox). */
     transport(): CommandTransport<RegisterCommandEnvelope>;
     /** The device id sent on every command. A change restarts the outbox. */
@@ -2577,4 +2633,4 @@ declare function tenderVoidCollection(): {
     readonly schema: RxJsonSchema<TenderVoid>;
 };
 
-export { type Actor, type AddLineInput, type AppliedDiscount, type BackendNotFound, type BasketLine, CartError, type CashMovement, type CashMovementCollection, type CatalogueEntry, type CatalogueGridColumns, type CatalogueView, type CatalogueViewAction, type CatalogueViewState, type ChargeInput, type ChargeLine, type Closure, type ClosureCollection, type ClosureContext, type ClosureScope, type CommandTransport, type Correction, CurrencyProvider, type CurrencyProviderProps, type CustomerSummary, DEFAULT_CATALOGUE_VIEW_STATE, DISCOUNTS_UNSUPPORTED, type Discount, type DisplayLine, type DisplayTotals, type FeeLine, type FinalizeOptions, type HttpTransportOptions, type LedgerRow, type LineItem, type LineTaxLine, type LogEntry, type LogLevel, type LogSink, type Logger, MAX_TENDER_MINOR, MICROS_PER_MINOR, type Movement$1 as Movement, type MovementType, type Order, type OrderBuilder, type OrderBuilderOptions, OrderContentMismatchError, type OrderManager, type OrderManagerOptions, type OrderOutbox, type OrderOutboxOptions, type OrderTaxTotals, type OrderTransportContext, type OutboxState, PRODUCT_SORT_FIELDS, type ParkedOrderSummary, type Payment, type PaymentMethod, type PaymentTransport, type PlanLeg, type PosOrder, type PosOrderLine, type PosOrderLocalWarning, PosOrderOpenClosedError, type PosOrderPayment, type PosOrderServerFailures, type PosOrderSyncStatus, type ProductSort, type ProductSortValue, RECEIPT_SCHEMA_VERSION, REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS, type RateTaxLine, type ReceiptConfig, type ReceiptData, type ReceiptFiscal, type ReceiptLineItem, type ReceiptRegister, type ReceiptSoftware, type RecordedFigures, RegisterApprovalRequiredError, type RegisterBucket, RegisterCloseIncompleteError, type RegisterCommand, type RegisterCommandCollection, type RegisterCounters, type RegisterDocument, type RegisterFact, type RegisterHost, RegisterIdInvalidError, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, RegisterNeedsUpgradeError, type RegisterOutbox, type RegisterOutboxOptions, type RegisterSession, RegisterSessionAlreadyOpenError, RegisterSessionClosedError, type RegisterSessionCollection, RegisterSessionOpenClosedError, RegisterSessionRequiredError, type RegisterStore, RegisterTenderInProgressError, type Repository, type ResolveStoreSettingsOptions, SALE_SAVING, type SaleStage, type SentOrder, type ShippingLine, type SplitTab, type StoreSettingsResolution, type StoreSettingsState, TAX_ROUNDING_MIXED_NOTE, type TaxContext, type TaxLineInput, TaxProvider, type TaxProviderProps, type TaxRateMap, type TenderAction, type TenderKey, type TenderLineId, type TenderPlan, type TenderState, type TenderView, type TenderVoid, type TransportOutcome, UnsupportedOrderVersionError, type UseOrderOutboxOptions, type UseOrderOutboxResult, type UseRegisterOutboxOptions, type UseRegisterOutboxResult, type UseRegisterSessionOptions, activePlan, addEntryToCart, addPosOrderCollection, addRegisterSessionCollection, advancePerpetual, allocateOrderDiscount, appliedMinor, backToSelling, bindRegister, buildClosureDocument, buildReceiptData, buildXReportDocument, callbackSink, cashMovementSchema, catalogueEntries, catalogueViewReducer, changeMinor, clampClosureScope, closeNeedsApproval, closeSession, closureCommand, closureSchema, computeOrderTax, consoleSink, countVariance, createBackendNotFound, createHttpCommandTransport, createLogger, createOrderBuilder, createOrderManager, createOrderOutbox, createRegisterOutbox, createRepository, denominationTotal, denominations, deriveExpected, deriveSettled, ensureRegister, evenSplitShareMinor, exportCsv, finalizeOrder, findEntryByCode, formatClosureDate, getBoundRegisterId, getDeviceId, inCategory, initTenderState, initialTenderState, isKnownSessionStatus, isServerDecimal, labelKeys, listCategories, minorToDecimal, mintClosureNumber, mintUuid, movementCommand, movementFieldError, needsAttention, nextSaleCounter, normalizeAmount, normalizeCatalogueViewState, observeRegister$, openSession, openSessionSelector, orderDraftSchema, outboxLogger, overThreshold, parkedOrderSummaries$, parseMinor, planLegs, posOrderCollection, posOrderSchema, posOrdersLogger, productCategories, productSortValue, quickTenderedAmounts, ratePpmFromPercent, readBoundRegister, readRegister, reconcileRegisterCommands, recordMovement, recordRegisterFact, registerCommandCollection, registerCommandSchema, registerCommandsLogger, registerFactsLogger, registerSessionCollection, registerSessionSchema, registerSessionsLogger, requireOpenSession, resolveGridColumns, resolveStoreSettings, restoreOrderDraft, roundMicrosToMinor, saleLogger, sameSale, searchProducts, selectClosureRows, sessionOpenCommand, sessionTransitionCommand, sortProducts, stampSession, startCounting, stockOverlay$, stockOverlayAsOf$, taxFiguresForBasket, taxLinesByRate, taxLogger, taxMicros, taxProviderProps, tenderReducer, tenderVoidCollection, tenderVoidSchema, toOrderCreateEnvelope, unbindRegister, useCurrencyCode, useCurrencyFormatter, useOrderOutbox, useParkedSales, useRegisterOutbox, useRegisterSession, useSale, useStoreSettings, useTax, uuidv7, validAmount, varianceText, variantPriceLabel, voidMovement, withPricingContext, writeClosure, writeOrderDraft };
+export { type Actor, type AddLineInput, type AppliedDiscount, type BackendNotFound, type BasketLine, CartError, type CashMovement, type CashMovementCollection, type CatalogueEntry, type CatalogueGridColumns, type CatalogueView, type CatalogueViewAction, type CatalogueViewState, type ChargeInput, type ChargeLine, type Closure, type ClosureCollection, type ClosureContext, type ClosureScope, type CommandTransport, type Correction, CurrencyProvider, type CurrencyProviderProps, type CustomerSummary, DEFAULT_CATALOGUE_VIEW_STATE, DISCOUNTS_UNSUPPORTED, type Discount, type DisplayLine, type DisplayTotals, type FeeLine, type FinalizeOptions, type HttpTransportOptions, type LedgerRow, type LineItem, type LineTaxLine, type LogEntry, type LogLevel, type LogSink, type Logger, MAX_TENDER_MINOR, MICROS_PER_MINOR, type Movement$1 as Movement, type MovementType, type Order, type OrderBuilder, type OrderBuilderOptions, OrderContentMismatchError, type OrderManager, type OrderManagerOptions, type OrderOutbox, type OrderOutboxOptions, type OrderTaxTotals, type OrderTransportContext, type OutboxState, PRODUCT_SORT_FIELDS, type ParkedOrderSummary, type Payment, type PaymentMethod, type PaymentTransport, type PlanLeg, type PosOrder, type PosOrderLine, type PosOrderLocalWarning, PosOrderOpenClosedError, type PosOrderPayment, type PosOrderServerFailures, type PosOrderSyncStatus, type ProductSort, type ProductSortValue, RECEIPT_SCHEMA_VERSION, REGISTER_SESSION_MIGRATION_CLOSE_WAIT_MS, type RateTaxLine, type ReceiptConfig, type ReceiptData, type ReceiptFiscal, type ReceiptLineItem, type ReceiptRegister, type ReceiptSoftware, type RecordedFigures, RegisterApprovalRequiredError, type RegisterBucket, RegisterCloseIncompleteError, type RegisterCommand, type RegisterCommandCollection, type RegisterCounters, type RegisterDocument, type RegisterFact, type RegisterHost, RegisterIdInvalidError, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, RegisterNeedsUpgradeError, type RegisterOutbox, type RegisterOutboxOptions, type RegisterSession, RegisterSessionAlreadyOpenError, RegisterSessionClosedError, type RegisterSessionCollection, RegisterSessionConflictError, RegisterSessionOpenClosedError, RegisterSessionRequiredError, type RegisterStore, RegisterTakeOverError, RegisterTenderInProgressError, type Repository, type ResolveStoreSettingsOptions, SALE_SAVING, type SaleStage, type SentOrder, type ShippingLine, type SplitTab, type StoreSettingsResolution, type StoreSettingsState, TAX_ROUNDING_MIXED_NOTE, type TaxContext, type TaxLineInput, TaxProvider, type TaxProviderProps, type TaxRateMap, type TenderAction, type TenderKey, type TenderLineId, type TenderPlan, type TenderState, type TenderView, type TenderVoid, type TransportOutcome, UnsupportedOrderVersionError, type UseOrderOutboxOptions, type UseOrderOutboxResult, type UseRegisterOutboxOptions, type UseRegisterOutboxResult, type UseRegisterSessionOptions, abandonSession, activePlan, addEntryToCart, addPosOrderCollection, addRegisterSessionCollection, adoptRegisterResults, advancePerpetual, allocateOrderDiscount, appliedMinor, backToSelling, bindRegister, buildClosureDocument, buildReceiptData, buildXReportDocument, callbackSink, cashMovementSchema, catalogueEntries, catalogueViewReducer, changeMinor, clampClosureScope, closeNeedsApproval, closeSession, closureCommand, closureSchema, computeOrderTax, consoleSink, countVariance, createBackendNotFound, createHttpCommandTransport, createLogger, createOrderBuilder, createOrderManager, createOrderOutbox, createRegisterOutbox, createRepository, denominationTotal, denominations, deriveExpected, deriveSettled, ensureRegister, evenSplitShareMinor, exportCsv, finalizeOrder, findEntryByCode, formatClosureDate, getBoundRegisterId, getDeviceId, inCategory, initTenderState, initialTenderState, isKnownSessionStatus, isServerDecimal, labelKeys, listCategories, minorToDecimal, mintClosureNumber, mintUuid, movementCommand, movementFieldError, needsAttention, nextSaleCounter, normalizeAmount, normalizeCatalogueViewState, observeRegister$, openSession, openSessionSelector, orderDraftSchema, outboxLogger, overThreshold, parkedOrderSummaries$, parseMinor, planLegs, posOrderCollection, posOrderSchema, posOrdersLogger, productCategories, productSortValue, quickTenderedAmounts, ratePpmFromPercent, readBoundRegister, readRegister, reconcileRegisterCommands, recordMovement, recordRegisterFact, registerCommandCollection, registerCommandSchema, registerCommandsLogger, registerFactsLogger, registerSessionCollection, registerSessionSchema, registerSessionsLogger, requireOpenSession, resolveGridColumns, resolveStoreSettings, restoreOrderDraft, roundMicrosToMinor, saleLogger, sameSale, searchProducts, selectClosureRows, sessionOpenCommand, sessionTransitionCommand, sortProducts, stampSession, startCounting, stockOverlay$, stockOverlayAsOf$, takeOverSession, taxFiguresForBasket, taxLinesByRate, taxLogger, taxMicros, taxProviderProps, tenderReducer, tenderVoidCollection, tenderVoidSchema, toOrderCreateEnvelope, unbindRegister, useCurrencyCode, useCurrencyFormatter, useOrderOutbox, useParkedSales, useRegisterOutbox, useRegisterSession, useSale, useStoreSettings, useTax, uuidv7, validAmount, varianceText, variantPriceLabel, voidMovement, withPricingContext, writeClosure, writeOrderDraft };

package/dist/index.js

@@ -2813,6 +2813,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 +2854,8 @@ var TRANSITIONS = {
   counting: ["open", "closed"],
   closed: [],
   conflict: [],
-  superseded: []
+  superseded: [],
+  abandoned: []
 };
 function isKnownSessionStatus(status) {
   return Object.hasOwn(TRANSITIONS, status);
@@ -2858,6 +2873,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" };
@@ -3603,8 +3619,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 +3638,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 +3696,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 +3707,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 +3719,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 +3747,94 @@ 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 }) {
+  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 +3875,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) => ({
@@ -3777,8 +3891,8 @@ function useRegisterSession(options) {
   const { commands } = options;
   const commandEnabled = (options.capabilities?.register ?? 0) >= 1;
   const commandTarget = useMemo3(
-    () => enabled && commandEnabled && commands && sessions && movements && closures && register && registerId ? { commands, sessions, movements, closures, host: register, storeKey, registerId } : null,
-    [enabled, commandEnabled, commands, sessions, movements, closures, register, storeKey, registerId]
+    () => 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,6 +3907,13 @@ 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;
     return combineLatest([
@@ -3804,10 +3925,11 @@ function useRegisterSession(options) {
       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 })));
+        watchFresh(orders, { selector: { sessionId: current2.id } }),
+        commandTarget ? watchFresh(commandTarget.commands, { selector: { key: `session.open:${current2.id}` } }) : of([])
+      ]).pipe(map5(([entries2, sales2, opens]) => ({ rows, closureRows, reservation, entries: entries2, sales: sales2, open: opens[0] })));
     }));
-  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId]);
+  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId, commandTarget]);
   const tender = useRef2(tenderInProgress);
   tender.current = tenderInProgress;
   const closing = useSyncExternalStore(subscribeClosing, () => closingByRegister.has(registerId ?? ""));
@@ -3862,6 +3984,8 @@ 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) }) : {};
@@ -3887,6 +4011,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 +4027,39 @@ 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();
+        if ((options.capabilities?.register ?? 0) < 2) throw new RegisterTakeOverError("REGISTER_TAKEOVER_UNSUPPORTED");
+        await takeOverSession({ ...commandTarget, sessionId: row.id });
+      },
+      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 +4068,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))) {
@@ -5203,7 +5352,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 +5372,7 @@ function createRegisterOutbox(options) {
   let running;
   let timer;
   let subscription;
+  let sessionsSubscription;
   let stopped = false;
   let insertedDuringRun = false;
   let stoppedDuringRun = false;
@@ -5244,7 +5394,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 +5407,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 +5436,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 +5445,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 +5581,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 +5597,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 +5610,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 +5622,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 +5638,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,
@@ -5860,17 +6025,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,
@@ -5975,6 +6144,7 @@ export {
   startCounting,
   stockOverlay$,
   stockOverlayAsOf$,
+  takeOverSession,
   taxFiguresForBasket,
   taxLinesByRate,
   taxLogger,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyui/pos",
-  "version": "3.7.0",
+  "version": "3.8.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.7.0",
+    "@tallyui/core": "^3.8.0",
     "react": ">=18",
     "rxdb": "~17.5.0",
     "rxjs": ">=7"
   },
   "devDependencies": {
-    "@tallyui/core": "3.7.0",
+    "@tallyui/core": "3.8.0",
     "@types/react": ">=18",
     "react": "^19.2.4",
     "rxdb": "17.5.0",
     "rxjs": "7.8.2",
-    "@tallyui/connector-medusa": "3.7.0",
-    "@tallyui/connector-woocommerce": "3.7.0",
-    "@tallyui/database": "3.7.0"
+    "@tallyui/connector-medusa": "3.8.0",
+    "@tallyui/connector-woocommerce": "3.8.0",
+    "@tallyui/database": "3.8.0"
   },
   "scripts": {
     "build": "tsup",

package/src/index.ts

@@ -78,11 +78,11 @@ 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 { registerCommandSchema, registerCommandCollection, registerCommandsLogger, sessionOpenCommand, sessionTransitionCommand, movementCommand, closureCommand, reconcileRegisterCommands, adoptRegisterResults, takeOverSession, abandonSession } 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, RegisterNeedsUpgradeError, isKnownSessionStatus, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, openSessionSelector, requireOpenSession, stampSession, openSession, startCounting, backToSelling, closeSession, recordMovement, voidMovement, writeClosure } from './register';
+export { RegisterSessionRequiredError, RegisterSessionClosedError, RegisterNeedsUpgradeError, RegisterSessionConflictError, RegisterTakeOverError, 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

@@ -2,6 +2,7 @@ import type { CommandResult, RegisterCommandEnvelope } from '@tallyui/core';
 import type { RxCollection } from 'rxdb';
 import { BehaviorSubject, type Observable, type Subscription } from 'rxjs';
 import { registerCommandsLogger, type RegisterCommand } from '../register/register-commands';
+import type { RegisterSessionCollection } from '../register/session-store';
 import { countFresh, readFresh } from '../rxdb';
 import { createBackendNotFound, type BackendNotFound } from './backend-not-found';
 import { STUCK_AFTER_MS } from './order-outbox';
@@ -12,6 +13,9 @@ export const NON_BLOCKING_REJECTIONS: ReadonlySet<string> = new Set(['register_s
 
 export interface RegisterOutboxOptions {
   collection: RxCollection<RegisterCommand>;
+  /** The till's `register_sessions`. With it, a refused open (`register_session_already_open`) stops blocking its register
+   * once its session is `abandoned` (ADR-078 decision 9). Without it, that refusal always blocks. */
+  sessions?: RegisterSessionCollection;
   transport: CommandTransport<RegisterCommandEnvelope>;
   deviceId: string;
   /** Checked at the start of every run; false sends nothing. */
@@ -42,7 +46,7 @@ function plainCommand({ key, registerId, seq, commandId, type, version, payload,
 }
 
 export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOutbox {
-  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 ?? 1000;
@@ -62,6 +66,7 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
   let running: Promise<void> | undefined;
   let timer: ReturnType<typeof setTimeout> | undefined;
   let subscription: Subscription | undefined;
+  let sessionsSubscription: Subscription | undefined;
   let stopped = false;
   let insertedDuringRun = false;
   let stoppedDuringRun = false;
@@ -92,7 +97,15 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
     for (const { commandId } of commands) clocks.set(commandId, { ...(clocks.get(commandId) ?? { since: at, firstFailedAt: at }), seq: ++failureSeq, reason });
   }
 
+  function isNonBlocking(command: RegisterCommand, abandoned: ReadonlySet<string>): boolean {
+    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: Partial<OutboxState> = {}) {
+    const abandoned = new Set(sessions && clocks.size
+      ? (await readFresh(sessions, { selector: { status: 'abandoned' } })).map((session) => session.id) : []);
     const pending = await countFresh(collection, { syncStatus: 'pending' });
     // Only commands in a register's sendable prefix (pending, before its first rejected command) keep a clock.
     const sendable = new Set<string>();
@@ -100,7 +113,7 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
     if (clocks.size) for (const command of await readFresh(collection, { selector: { syncStatus: { $in: ['pending', 'rejected'] } },
       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)) sendable.add(command.commandId);
     }
     for (const id of clocks.keys()) if (!sendable.has(id)) clocks.delete(id);
@@ -123,6 +136,8 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
       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, {
@@ -131,7 +146,7 @@ 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' && isNonBlocking(command, abandoned)) continue;
           if (command.syncStatus === 'rejected') break;
           commands.push(command);
           if (command.type === 'register.session.open' || commands.length >= batchSize) break;
@@ -241,6 +256,12 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
           flush().catch(() => {});
         }
       });
+      if (sessions && !sessionsSubscription) sessionsSubscription = sessions.$.subscribe((event) => {
+        if (event.documentData?.status === 'abandoned') {
+          insertedDuringRun = true;
+          flush().catch(() => {});
+        }
+      });
       if (!stopped) flush().catch(() => {});
     },
     stop() {
@@ -249,6 +270,8 @@ export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOu
       timer = undefined;
       subscription?.unsubscribe();
       subscription = undefined;
+      sessionsSubscription?.unsubscribe();
+      sessionsSubscription = undefined;
       missingSubscription?.unsubscribe(); missingSubscription = undefined;
       state$.next({ ...state$.value, nextAttemptAt: undefined });
     },

package/src/outbox/use-register-outbox.ts

@@ -1,6 +1,7 @@
 import type { RegisterCommandEnvelope } from '@tallyui/core';
 import { useEffect, useRef, useState } from 'react';
 import type { RegisterCommandCollection } from '../register/register-commands';
+import type { RegisterSessionCollection } from '../register/session-store';
 import { createRegisterOutbox, type RegisterOutboxOptions } from './register-outbox';
 import type { CommandTransport, OutboxState } from './types';
 
@@ -9,6 +10,8 @@ const idle: OutboxState = { pending: 0, sending: false };
 export interface UseRegisterOutboxOptions {
   /** `register_commands` (see `registerCommandCollection()`); `null` while it opens or when there's no store. A new collection (a store switch) restarts the outbox. */
   commands: RegisterCommandCollection | null;
+  /** The till's `register_sessions`; abandoned sessions unblock refused opens. A new collection restarts the outbox. */
+  sessions?: RegisterSessionCollection | null;
   /** Builds the transport; called when the outbox is created: on each new collection or device id (twice under React StrictMode's double effect, which stops the first outbox). */
   transport(): CommandTransport<RegisterCommandEnvelope>;
   /** The device id sent on every command. A change restarts the outbox. */
@@ -27,7 +30,7 @@ export interface UseRegisterOutboxResult {
 }
 
 export function useRegisterOutbox(options: UseRegisterOutboxOptions): UseRegisterOutboxResult {
-  const { commands, deviceId } = options;
+  const { commands, sessions, deviceId } = options;
   const latest = useRef(options);
   latest.current = options;
   const current = useRef<{ commands: RegisterCommandCollection; deviceId: string; outbox: ReturnType<typeof createRegisterOutbox> } | null>(null);
@@ -37,6 +40,7 @@ export function useRegisterOutbox(options: UseRegisterOutboxOptions): UseRegiste
     setState(idle);
     if (!commands) return;
     const outbox = createRegisterOutbox({ collection: commands, deviceId, transport: latest.current.transport(),
+      sessions: sessions ?? undefined,
       isEnabled: latest.current.isEnabled ? () => latest.current.isEnabled?.() ?? true : undefined,
       onResult: latest.current.onResult ? async (command, result) => { await latest.current.onResult?.(command, result); } : undefined,
       backendNotFound: latest.current.backendNotFound });
@@ -44,7 +48,7 @@ export function useRegisterOutbox(options: UseRegisterOutboxOptions): UseRegiste
     const status = outbox.state$.subscribe(setState);
     outbox.start();
     return () => { outbox.stop(); status.unsubscribe(); current.current = null; setState(idle); };
-  }, [commands, deviceId]);
+  }, [commands, sessions, deviceId]);
 
   const opened = current.current;
   return { state: opened?.commands === commands && opened.deviceId === deviceId ? state : idle,

package/src/register/index.ts

@@ -13,7 +13,7 @@ export {
 } from './register-document';
 export type { RegisterHost, RegisterCounters, RegisterBucket, RegisterStore, RegisterDocument } from './register-document';
 export {
-  RegisterSessionRequiredError, RegisterSessionClosedError, RegisterNeedsUpgradeError, isKnownSessionStatus, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, openSessionSelector,
+  RegisterSessionRequiredError, RegisterSessionClosedError, RegisterNeedsUpgradeError, RegisterSessionConflictError, RegisterTakeOverError, isKnownSessionStatus, RegisterMovementAmountError, RegisterMovementReasonError, RegisterMovementStrandedError, openSessionSelector,
   requireOpenSession, stampSession, openSession, startCounting, backToSelling, closeSession, recordMovement, voidMovement, writeClosure,
 } from './session-store';
 export type { RegisterSessionCollection, CashMovementCollection, ClosureCollection } from './session-store';
@@ -30,4 +30,5 @@ export { registerFactsLogger, recordRegisterFact, type Actor, type RegisterFact
 export { useRegisterSession, RegisterTenderInProgressError, RegisterSessionAlreadyOpenError, RegisterCloseIncompleteError, RegisterApprovalRequiredError } from './use-register-session';
 export type { UseRegisterSessionOptions } from './use-register-session';
 export { registerCommandSchema, registerCommandCollection, registerCommandsLogger, sessionOpenCommand, sessionTransitionCommand, movementCommand, closureCommand, reconcileRegisterCommands } from './register-commands';
+export { adoptRegisterResults, takeOverSession, abandonSession } from './register-adoption';
 export type { RegisterCommand, RegisterCommandCollection } from './register-commands';

package/src/register/register-adoption.ts

@@ -0,0 +1,102 @@
+import { readFresh } from '../rxdb';
+import { uuidv7 } from '../pos-order/uuidv7';
+import { registerCommandsLogger, type RegisterCommandCollection } from './register-commands';
+import type { RegisterSession } from './schemas';
+import { isKnownSessionStatus, RegisterSessionRequiredError, RegisterTakeOverError, type RegisterSessionCollection } from './session-store';
+
+const chains = new WeakMap<RegisterCommandCollection, Promise<void>>();
+
+/**
+ * Applied opens fill a missing resume id; refused opens make open/counting sessions conflict.
+ * Superseded rejections make open/counting sessions terminal; a conflict session leaves only by an applied open or abandon (ADR-078 decision 9); terminal/unknown states stay untouched.
+ * Applied conflict opens restore the latest transition's counting state, otherwise open; pending rows do nothing.
+ * Answers are walked in seq/key order; adoption is idempotent and safe to run at any time.
+ */
+export async function adoptRegisterResults({ commands, sessions, registerId }: {
+  commands: RegisterCommandCollection; sessions: RegisterSessionCollection; registerId: string;
+}): Promise<void> {
+  const run = (chains.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: RegisterSession): RegisterSession => {
+        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: unknown) => {
+    registerCommandsLogger.error('Register result adoption failed', { context: { registerId, error: String(error) } });
+  });
+  chains.set(commands, run.then(() => undefined, () => undefined));
+  return run;
+}
+
+export async function takeOverSession({ commands, sessions, sessionId, now }: {
+  commands: RegisterCommandCollection; sessions: RegisterSessionCollection; sessionId: string; now?: string;
+}): Promise<void> {
+  const run = (chains.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 ?? new Date().toISOString() };
+    });
+  });
+  chains.set(commands, run.then(() => undefined, () => undefined));
+  return run;
+}
+
+async function finishAbandon({ commands, sessions, sessionId, now }: Parameters<typeof takeOverSession>[0]) {
+  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 ?? new Date().toISOString(),
+    }));
+  }
+  await (await sessions.findOne(sessionId).exec(true)).incrementalModify((doc) => doc.status === 'conflict' ? { ...doc, status: 'abandoned' } : doc);
+}
+
+export async function abandonSession(input: Parameters<typeof takeOverSession>[0]): Promise<void> {
+  const { commands, sessions, sessionId } = input;
+  const run = (chains.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);
+  });
+  chains.set(commands, run.then(() => undefined, () => undefined));
+  return run;
+}

package/src/register/register-commands.ts

@@ -38,16 +38,28 @@ export const registerCommandSchema: RxJsonSchema<RegisterCommand> = {
 };
 export const registerCommandCollection = () => ({ schema: registerCommandSchema });
 
-type BuiltCommand = Pick<RegisterCommand, 'key' | 'type' | 'payload'> & { version: 1 };
+type BuiltCommand = Pick<RegisterCommand, 'key' | 'type' | 'payload'> & { version: 1 | 2 };
 
-export function sessionOpenCommand(s: RegisterSession): BuiltCommand {
-  return { key: `session.open:${s.id}`, type: 'register.session.open', version: 1, payload: {
+/** ADR-078: 1 to 64 characters after trim. */
+export function deviceNameOf(name: string | null | undefined): string | undefined {
+  let trimmed = name?.trim();
+  if (trimmed && trimmed.length > 64) {
+    const last = trimmed.charCodeAt(63);
+    trimmed = trimmed.slice(0, last >= 0xd800 && last <= 0xdbff ? 63 : 64).trimEnd();
+  }
+  return trimmed || undefined;
+}
+
+export function sessionOpenCommand(s: RegisterSession, v2?: { deviceName?: string | null }): BuiltCommand {
+  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, countedFloatMinor: s.counted_float_minor,
     ...(s.store_key == null ? {} : { storeKey: s.store_key }),
     ...(s.business_day == null ? {} : { businessDay: s.business_day }),
     ...(s.opened_by == null ? {} : { openedBy: s.opened_by }),
     ...(s.expected_float_minor == null ? {} : { expectedFloatMinor: s.expected_float_minor }),
     ...(s.opening_variance_minor == null ? {} : { openingVarianceMinor: s.opening_variance_minor }),
+    ...(deviceName === undefined ? {} : { deviceName }),
   } satisfies RegisterSessionOpenPayload };
 }
 
@@ -88,9 +100,10 @@ export function closureCommand(c: Closure): BuiltCommand {
 const chains = new WeakMap<RegisterCommandCollection, Map<string, Promise<void>>>();
 
 /** Appends missing facts in dependency order; the bytes of an existing key never change. */
-export function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed }: {
+export function reconcileRegisterCommands({ commands, sessions, movements, closures, host, storeKey, registerId, now, observed, registerContract, deviceName }: {
   commands: RegisterCommandCollection; sessions: RegisterSessionCollection; movements: CashMovementCollection;
   closures: ClosureCollection; host: RegisterHost; storeKey: string; registerId: string; now?: string; observed?: RegisterSession[];
+  registerContract?: number; deviceName?: string | null;
 }): Promise<string[]> {
   // `conflict` and `superseded` are local states derived from the store's answers (ADR-078 decision 9), never sent as a transition.
   const sentStatus = (s: RegisterSession): s is RegisterSession & { status: RegisterSessionTransitionPayload['status'] } => s.status === 'open' || s.status === 'counting' || s.status === 'closed';
@@ -106,8 +119,8 @@ export function reconcileRegisterCommands({ commands, sessions, movements, closu
     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}`)))
+      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 } }),
@@ -119,7 +132,7 @@ export function reconcileRegisterCommands({ commands, sessions, movements, closu
       events.push(...entries.filter((entry) => entry.type !== 'void').map(movementCommand),
         ...entries.filter((entry) => entry.type === 'void').map(movementCommand));
       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,
+      return { session, number: closureRows[0]?.number, built: [(registerContract ?? 0) >= 2 ? sessionOpenCommand(session, { deviceName }) : sessionOpenCommand(session), ...events,
         ...closureRows.map((closure) => closureCommand(closure))] };
     }));
     facts.sort((a, b) => Number(a.session.status !== 'closed') - Number(b.session.status !== 'closed')

package/src/register/schemas.ts

@@ -24,8 +24,8 @@ export interface RegisterSession {
   register_id: string;
   /** The app's neutral store key (see `bindRegister`). */
   store_key?: string | null;
-  /** Stored status is an open string so a later local state costs no migration (ADR-078 decision 9); the union names today's states. */
-  status: 'open' | 'counting' | 'closed' | 'conflict' | 'superseded';
+  /** Stored status is an open string so a later local state costs no migration (ADR-078 decision 9); the union names today's states. `abandoned` is local only and terminal (the cashier chose another register while in conflict). */
+  status: 'open' | 'counting' | 'closed' | 'conflict' | 'superseded' | 'abandoned';
   /** The store session this local id was resumed as (ADR-078 decision 2), never the session that superseded it; null until a resume. */
   server_session_id?: string | null;
   /** The store's day the session opened, `yyyy-MM-dd`. */

package/src/register/session-store.ts

@@ -49,6 +49,24 @@ export class RegisterNeedsUpgradeError extends Error {
   }
 }
 
+/** Opening is refused while the register has a `conflict` session (ADR-078); its message can be shown to a cashier as it is. */
+export class RegisterSessionConflictError extends Error {
+  readonly code = 'REGISTER_SESSION_CONFLICT';
+  constructor() {
+    super('This register is open on another till. Take it over or choose another register.');
+    this.name = 'RegisterSessionConflictError';
+  }
+}
+
+export class RegisterTakeOverError extends Error {
+  constructor(readonly code: 'REGISTER_TAKEOVER_UNSUPPORTED' | 'REGISTER_TAKEOVER_PENDING') {
+    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.name = 'RegisterTakeOverError';
+  }
+}
+
 /** ADR-068 6a: movement amounts must be safe integers, positive for paid_in/paid_out and zero for no_sale. */
 export class RegisterMovementAmountError extends Error {
   constructor(type: 'paid_in' | 'paid_out' | 'no_sale', amountMinor: number) {
@@ -80,7 +98,7 @@ export class RegisterMovementStrandedError extends Error {
   }
 }
 
-/** Every move a session may make. Nothing leaves `closed`; everything else is refused.
+/** Every move a session may make. `closed` and `abandoned` are terminal: nothing leaves them; everything else is refused.
  * No cashier move leaves `conflict` or `superseded`; the store's answers set them (ADR-078). */
 const TRANSITIONS: Record<RegisterSession['status'], readonly RegisterSession['status'][]> = {
   open: ['counting', 'closed'],
@@ -88,6 +106,7 @@ const TRANSITIONS: Record<RegisterSession['status'], readonly RegisterSession['s
   closed: [],
   conflict: [],
   superseded: [],
+  abandoned: [],
 };
 
 /** Whether this build knows the stored session status. */
@@ -116,6 +135,7 @@ async function requireLiveSession(sessions: RegisterSessionCollection, id: strin
   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;
 }
 

package/src/register/use-register-session.ts

@@ -17,13 +17,14 @@
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import { combineLatest, map, of, switchMap } from 'rxjs';
 import type { RxCollection } from 'rxdb';
-import type { ServerCapabilities } from '@tallyui/core';
+import type { RegisterSessionAlreadyOpenData, ServerCapabilities } from '@tallyui/core';
 import type { PosOrder } from '../pos-order/types';
 import { readFresh, watchFresh } from '../rxdb';
 import { deriveExpected, type LedgerRow } from './expected';
 import { recordRegisterFact, registerFactsLogger, type Actor } from './facts';
 import { closeNeedsApproval } from './register-count.helpers';
-import { reconcileRegisterCommands, registerCommandsLogger, type RegisterCommandCollection } from './register-commands';
+import { abandonSession, adoptRegisterResults, takeOverSession } from './register-adoption';
+import { reconcileRegisterCommands, registerCommandsLogger, type RegisterCommand, type RegisterCommandCollection } from './register-commands';
 import { observeRegister$, readRegister, type RegisterBucket, type RegisterDocument, type RegisterHost } from './register-document';
 import type { CashMovement, Closure, RegisterSession } from './schemas';
 import * as store from './session-store';
@@ -84,6 +85,8 @@ export interface UseRegisterSessionOptions {
   /** `register_commands`, created with `registerCommandCollection()`; `null` while it opens. */
   commands?: RegisterCommandCollection | null;
   capabilities?: ServerCapabilities;
+  /** The till's name from the app's settings, sent on a register v2 open; the app supplies its platform fallback. */
+  deviceName?: string | null;
   /** `pos_orders`: a session's sales are those whose `sessionId` is its id. */
   orders: RxCollection<PosOrder> | null;
   /** The register document's host, for the closure number and perpetual totals (`writeClosure`); `null` while it opens. */
@@ -116,6 +119,7 @@ type Reservation = RegisterBucket['closure_reservation'];
 type Snapshot = {
   rows: RegisterSession[]; closureRows: Closure[]; reservation: Reservation;
   entries: CashMovement[]; sales: PosOrder[];
+  open?: RegisterCommand;
 };
 
 const reservationOf = (register: RegisterDocument | null, storeKey: string, registerId: string) =>
@@ -128,12 +132,13 @@ const unwritten = (row: RegisterSession, closureRows: readonly { id: string }[])
 /**
  * The session for this register: first the one an unapplied closure reservation names (its close
  * was interrupted after the number was reserved, perhaps after its row was written), so it can
- * finish; then the open or counting one; then a closed one whose closure row was never written; null if any status is unknown.
+ * finish; then the open or counting one; then a conflict one; then a closed one whose closure row was never written; null if any status is unknown.
  */
 function currentSession(rows: RegisterSession[], closureRows: Closure[], reservation: Reservation) {
   if (rows.some((row) => !store.isKnownSessionStatus(row.status))) return null;
   return (reservation && !reservation.applied ? rows.find((row) => row.id === reservation.row.session_id) : undefined)
-    ?? rows.find((row) => row.status !== 'closed')
+    ?? rows.find((row) => row.status === 'open' || row.status === 'counting')
+    ?? rows.find((row) => row.status === 'conflict')
     ?? rows.find((row) => unwritten(row, closureRows))
     ?? null;
 }
@@ -151,8 +156,8 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
   const { commands } = options;
   const commandEnabled = (options.capabilities?.register ?? 0) >= 1;
   const commandTarget = useMemo(() => 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]);
+    ? { 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 = useRef(commandTarget);
   commandTargetRef.current = commandTarget;
   const reconcile = (row?: RegisterSession) => {
@@ -167,6 +172,13 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
     });
   };
   useEffect(reconcile, [commandTarget]);
+  useEffect(() => {
+    if (!commandTarget) return;
+    const subscription = commandTarget.commands.find({ selector: { registerId: commandTarget.registerId } }).$.subscribe(() => {
+      void adoptRegisterResults(commandTarget);
+    });
+    return () => subscription.unsubscribe();
+  }, [commandTarget]);
   const source = useMemo(() => {
     if (!enabled || !sessions || !movements || !closures || !orders || !registerId || !register) return null;
     return combineLatest([
@@ -179,9 +191,10 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
       return combineLatest([
         watchFresh(movements, { selector: { session_id: current.id } }),
         watchFresh(orders, { selector: { sessionId: current.id } }),
-      ]).pipe(map(([entries, sales]) => ({ rows, closureRows, reservation, entries, sales })));
+        commandTarget ? watchFresh(commandTarget.commands, { selector: { key: `session.open:${current.id}` } }) : of([]),
+      ]).pipe(map(([entries, sales, opens]) => ({ rows, closureRows, reservation, entries, sales, open: opens[0] })));
     }));
-  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId]);
+  }, [enabled, sessions, movements, closures, orders, register, storeKey, registerId, commandTarget]);
   // A latest-value ref: an `actions` object from an earlier render still sees the current flag.
   const tender = useRef(tenderInProgress);
   tender.current = tenderInProgress;
@@ -251,6 +264,12 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
     }
   }, [data, source]);
   const session = data ? currentSession(data.rows, data.closureRows, data.reservation) : null;
+  const refusal = data?.open?.error?.data as RegisterSessionAlreadyOpenData | undefined;
+  const conflict = session?.status !== 'conflict' || !commandTarget ? undefined
+    : 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 } : undefined;
   const entries = data?.entries ?? [];
   const sales = data?.sales ?? [];
   const expected = session
@@ -282,6 +301,8 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
 
   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) => !store.isKnownSessionStatus(row.status)) ?? false,
     movements: entries,
@@ -297,17 +318,35 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
     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 } : undefined,
+    saleSession: session && sessions && (session.status === 'open' || session.status === 'counting') ? { id: session.id, sessions } : undefined,
     /** 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();
+        if ((options.capabilities?.register ?? 0) < 2) throw new store.RegisterTakeOverError('REGISTER_TAKEOVER_UNSUPPORTED');
+        await takeOverSession({ ...commandTarget, sessionId: row.id });
+      },
+      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: { expectedFloatMinor: number | null; countedFloatMinor: number }) => {
         // A double tap: the second call sees the first's promise, set before its first await.
@@ -318,7 +357,8 @@ export function useRegisterSession(options: UseRegisterSessionOptions) {
           // The storage, not the rendered snapshot or a cached query, which can lag a new write.
           const rows = await readFresh(sessions, { selector: { register_id: registerId } });
           if (rows.some((row) => !store.isKnownSessionStatus(row.status))) throw new store.RegisterNeedsUpgradeError();
-          if (rows.some((row) => row.status !== 'closed')) throw new RegisterSessionAlreadyOpenError();
+          if (rows.some((row) => row.status === 'conflict')) throw new store.RegisterSessionConflictError();
+          if (rows.some((row) => row.status === 'open' || row.status === 'counting')) throw new RegisterSessionAlreadyOpenError();
           // Closure rows before the reservation: a close reserves, then inserts its row, then applies the
           // reservation, so a close landing between the two reads is still caught by one of them.
           const closureRows = await readFresh(closures, { selector: { register_id: registerId } });