@tallyui/pos 0.1.0 → 3.0.0-next.0

package/src/outbox/register-outbox.ts

@@ -0,0 +1,250 @@
+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 { countFresh, readFresh } from '../rxdb';
+import { createBackendNotFound, type BackendNotFound } from './backend-not-found';
+import { STUCK_AFTER_MS } from './order-outbox';
+import type { CommandTransport, OutboxState } from './types';
+
+export interface RegisterOutboxOptions {
+  collection: RxCollection<RegisterCommand>;
+  transport: CommandTransport<RegisterCommandEnvelope>;
+  deviceId: string;
+  /** Checked at the start of every run; false sends nothing. */
+  isEnabled?: () => boolean;
+  /** Runs before marking, so a crash resends; a throw is logged and marking continues. */
+  onResult?: (command: RegisterCommand, result: CommandResult) => Promise<void> | void;
+  batchSize?: number;
+  initialBackoffMs?: number;
+  maxBackoffMs?: number;
+  random?: () => number;
+  now?: () => number;
+  /** Tests only: overrides STUCK_AFTER_MS. */
+  stuckAfterMs?: number;
+  /** Counts 404s toward OutboxState.backendMissing; pass the order outbox's too, so either one's 404s show one notice. */
+  backendNotFound?: BackendNotFound;
+}
+export interface RegisterOutbox {
+  flush(): Promise<void>;
+  start(): void;
+  stop(): void;
+  state$: Observable<OutboxState>;
+}
+
+function plainCommand({ key, registerId, seq, commandId, type, version, payload, createdAt, syncStatus,
+  error, result, updatedAt }: RegisterCommand): RegisterCommand {
+  return structuredClone({ key, registerId, seq, commandId, type, version, payload, createdAt, syncStatus,
+    ...(error ? { error } : {}), ...(result ? { result } : {}), updatedAt });
+}
+
+export function createRegisterOutbox(options: RegisterOutboxOptions): RegisterOutbox {
+  const { collection, transport, deviceId } = options;
+  const size = options.batchSize;
+  const batchSize = Math.max(1, Math.min(typeof size === 'number' && Number.isFinite(size) ? Math.floor(size) : 10, 10));
+  const initialBackoff = options.initialBackoffMs ?? 1000;
+  const maxBackoff = options.maxBackoffMs ?? 60000;
+  const random = options.random ?? Math.random;
+  const now = options.now ?? Date.now;
+  const state$ = new BehaviorSubject<OutboxState>({ pending: 0, sending: false });
+  const backendNotFound = options.backendNotFound ?? createBackendNotFound();
+  let missingSubscription: Subscription | undefined; // stop() lets go of the (maybe shared) tracker; start() and flush() take it up again
+  const watchBackendMissing = () => missingSubscription ??= backendNotFound.backendMissing$.subscribe((backendMissing) => {
+    if (backendMissing !== state$.value.backendMissing) state$.next({ ...state$.value, backendMissing });
+  });
+  watchBackendMissing();
+  const attempts = new Map<string, number>();
+  let backoff = initialBackoff;
+  let unauthorizedSinceAccepted = 0;
+  let running: Promise<void> | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let subscription: Subscription | undefined;
+  let stopped = false;
+  let insertedDuringRun = false;
+  let stoppedDuringRun = false;
+  const stuckAfter = options.stuckAfterMs ?? STUCK_AFTER_MS;
+  // Each command's stuck clock counts only answered time, by the order outbox's rules. It starts when a batch that
+  // sent the command fails with a failure the store answered (a `retry` other than `network`, where `timeout` counts
+  // 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
+  // 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
+  // (accepted: register commands are few, and a restart re-sends at once).
+  const clocks = new Map<string, { since: number; pausedAt?: number; seq: number; reason: string }>();
+  let failureSeq = 0; // numbers failures, so `stuck` can name the latest reason
+
+  function stuckState(): OutboxState['stuck'] {
+    const stuck = [...clocks].filter(([, clock]) => (clock.pausedAt ?? now()) - clock.since >= stuckAfter);
+    if (!stuck.length) return undefined;
+    return { commandIds: stuck.map(([id]) => id), since: Math.min(...stuck.map(([, clock]) => clock.since)),
+      reason: stuck.reduce((latest, entry) => (entry[1].seq > latest[1].seq ? entry : latest))[1].reason,
+      orders: stuck.map(([commandId, { since, reason }]) => ({ commandId, since, reason })) };
+  }
+  function serverFailed(commands: RegisterCommand[], reason: string) {
+    const at = now();
+    for (const { commandId } of commands) clocks.set(commandId, { since: clocks.get(commandId)?.since ?? at, seq: ++failureSeq, reason });
+  }
+
+  async function updateState(patch: Partial<OutboxState> = {}) {
+    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>();
+    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);
+    }
+    for (const id of clocks.keys()) if (!sendable.has(id)) clocks.delete(id);
+    state$.next({ ...state$.value, ...patch, pending, stuck: stuckState() });
+  }
+  function scheduleRetry(reason: string, retryAfterMs = 0) {
+    state$.next({ ...state$.value, lastRetryReason: reason, stuck: stuckState() });
+    if (stopped) { stoppedDuringRun = true; return; }
+    const delay = Math.min(Math.max(retryAfterMs, backoff * (0.9 + 0.2 * random())), maxBackoff);
+    backoff = Math.min(backoff * 2, maxBackoff);
+    timer = setTimeout(() => { timer = undefined; flush().catch(() => {}); }, delay);
+    state$.next({ ...state$.value, sending: false, nextAttemptAt: now() + delay });
+  }
+
+  async function run() {
+    stoppedDuringRun = false;
+    while (!stopped) try {
+      await updateState({ sending: true, nextAttemptAt: undefined });
+      insertedDuringRun = false;
+      if (options.isEnabled?.() === false) return;
+      const pending = await readFresh(collection, { selector: { syncStatus: 'pending' } });
+      const registerIds = [...new Set(pending.map((command) => command.registerId))].sort();
+      let sent = false;
+      for (const registerId of registerIds) {
+        const ledger = await readFresh(collection, {
+          selector: { registerId, syncStatus: { $in: ['pending', 'rejected'] } },
+          sort: [{ seq: 'asc' }, { key: 'asc' }],
+        });
+        const commands: RegisterCommand[] = [];
+        for (const command of ledger) {
+          if (command.syncStatus === 'rejected') break;
+          commands.push(command);
+          if (commands.length >= batchSize) break;
+        }
+        if (stopped) { stoppedDuringRun = true; return; }
+        if (!commands.length) continue;
+        sent = true;
+        const batch: RegisterCommandEnvelope[] = commands.map((doc) => {
+          const attempt = (attempts.get(doc.commandId) ?? 0) + 1;
+          attempts.set(doc.commandId, attempt);
+          return { id: doc.commandId, type: doc.type, version: doc.version, payload: doc.payload,
+            createdAt: doc.createdAt, deviceId, attempt };
+        });
+        const outcome = await transport.send(batch);
+        backendNotFound.record(outcome, now());
+        const at = now();
+        if (outcome.kind === 'retry' && outcome.reason === 'network') for (const clock of clocks.values()) clock.pausedAt ??= at;
+        else for (const clock of clocks.values()) if (clock.pausedAt !== undefined) {
+          clock.since += at - clock.pausedAt;
+          clock.pausedAt = undefined;
+        }
+        if (outcome.kind === 'retry') {
+          if (outcome.reason !== 'network') serverFailed(commands, outcome.reason);
+          return scheduleRetry(outcome.reason, outcome.retryAfterMs);
+        }
+        if (outcome.kind === 'unauthorized') {
+          unauthorizedSinceAccepted++;
+          if (unauthorizedSinceAccepted < 3) return scheduleRetry('unauthorized');
+          state$.next({ ...state$.value, authRequired: true, lastRetryReason: 'unauthorized',
+            sending: false, nextAttemptAt: undefined });
+          return;
+        }
+        if (outcome.kind === 'refused') {
+          unauthorizedSinceAccepted = 0;
+          state$.next({ ...state$.value, refused: { status: outcome.status, reason: outcome.reason },
+            authRequired: false, lastRetryReason: 'refused', sending: false, nextAttemptAt: undefined });
+          return;
+        }
+        unauthorizedSinceAccepted = 0;
+        state$.next({ ...state$.value, authRequired: false, refused: undefined });
+        let progressed = false;
+        for (const command of commands) {
+          const result = outcome.results.find((entry) => entry.id === command.commandId);
+          if (!result) continue;
+          // Skip the query cache and ignore a command changed while its send was in flight.
+          const [stored] = await collection.storageInstance.findDocumentsById([command.key], false);
+          if (stored?.syncStatus !== 'pending' || stored.commandId !== command.commandId) continue;
+          const current = await collection.findOne(command.key).exec();
+          if (!current) continue;
+          const error = result.error && { code: result.error.code, message: result.error.message,
+            ...(result.error.data ? { data: result.error.data } : {}) };
+          const normalized: CommandResult = result.status === 'duplicate' && error
+            ? { id: result.id, status: 'rejected', error }
+            : { ...result, ...(error ? { error } : {}) };
+          try { await options.onResult?.(plainCommand(stored), normalized); }
+          catch (cause) { registerCommandsLogger.warn('Failed to apply register command result', { commandId: command.commandId, cause }); }
+          const updatedAt = new Date(now()).toISOString();
+          await current.incrementalModify((row) => {
+            if (row.syncStatus !== 'pending' || row.commandId !== command.commandId) return row;
+            return Object.assign(row, normalized.status === 'rejected'
+              ? { syncStatus: 'rejected', error: normalized.error, updatedAt }
+              : { syncStatus: 'applied', ...(normalized.register ? { result: normalized.register } : {}), updatedAt });
+          });
+          attempts.delete(command.commandId);
+          progressed = true;
+          await updateState();
+        }
+        if (!progressed) {
+          serverFailed(commands, 'no_progress');
+          return scheduleRetry('no_progress');
+        }
+        backoff = initialBackoff;
+        state$.next({ ...state$.value, lastRetryReason: undefined });
+      }
+      if (!sent) return;
+    } catch (error) {
+      scheduleRetry('error: ' + (error instanceof Error ? error.message : String(error)));
+      return;
+    }
+    stoppedDuringRun = true;
+  }
+
+  function flush(): Promise<void> {
+    if (running) return running;
+    stopped = false;
+    watchBackendMissing();
+    clearTimeout(timer);
+    timer = undefined;
+    running = Promise.resolve().then(run).finally(async () => {
+      try { await updateState({ sending: false }); } catch {}
+      running = undefined;
+      if ((insertedDuringRun || stoppedDuringRun) && !stopped && timer === undefined) flush().catch(() => {});
+    });
+    return running;
+  }
+  updateState().catch(() => {});
+  return {
+    state$,
+    flush,
+    start() {
+      stopped = false;
+      watchBackendMissing();
+      if (!subscription) subscription = collection.$.subscribe((event) => {
+        if (event.documentData?.syncStatus === 'pending' &&
+          (event.operation === 'INSERT' || event.operation === 'UPDATE')) {
+          insertedDuringRun = true;
+          flush().catch(() => {});
+        }
+      });
+      if (!stopped) flush().catch(() => {});
+    },
+    stop() {
+      stopped = true;
+      clearTimeout(timer);
+      timer = undefined;
+      subscription?.unsubscribe();
+      subscription = undefined;
+      missingSubscription?.unsubscribe(); missingSubscription = undefined;
+      state$.next({ ...state$.value, nextAttemptAt: undefined });
+    },
+  };
+}

package/src/outbox/types.test-d.ts

@@ -0,0 +1,22 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import type { AnyCommandEnvelope, CommandEnvelope, OrderCreateEnvelope, OrderCreatePayload, RegisterCommandEnvelope } from '@tallyui/core';
+import type { CommandTransport } from './types';
+
+describe('CommandTransport', () => {
+  it('defaults to order.create envelopes', () => {
+    expectTypeOf<Parameters<CommandTransport['send']>[0]>().toEqualTypeOf<CommandEnvelope<OrderCreatePayload>[]>();
+    const transport: CommandTransport = { send: async () => ({ kind: 'results', results: [] }) };
+    const batch: CommandEnvelope<OrderCreatePayload>[] = [];
+    transport.send(batch);
+  });
+
+  it('the wide transport is accepted where the order outbox wants the order transport', () => {
+    expectTypeOf<CommandTransport<AnyCommandEnvelope>>().toMatchTypeOf<CommandTransport<OrderCreateEnvelope>>();
+  });
+
+  it('the wide transport accepts register command envelopes', () => {
+    const transport: CommandTransport<AnyCommandEnvelope> = { send: async () => ({ kind: 'results', results: [] }) };
+    const batch: RegisterCommandEnvelope[] = [];
+    transport.send(batch);
+  });
+});

package/src/outbox/types.ts

@@ -0,0 +1,36 @@
+import type { AnyCommandEnvelope, CommandEnvelope, CommandResult, OrderCreatePayload } from '@tallyui/core';
+
+export type TransportOutcome =
+  | { kind: 'results'; results: CommandResult[] }
+  | { kind: 'unauthorized' }
+  | { kind: 'refused'; status: number; reason: string }
+  /** `reason` is `network` when the store could not be reached, `timeout` when a sent request got no answer in time,
+   * else what the store answered (`status_503`, `bad_body`, ...). The order outbox counts every reason but `network`. */
+  | { kind: 'retry'; reason: string; retryAfterMs?: number };
+
+export interface CommandTransport<E extends AnyCommandEnvelope = CommandEnvelope<OrderCreatePayload>> {
+  send(batch: E[]): Promise<TransportOutcome>;
+}
+
+export interface OutboxState {
+  pending: number;
+  /** The order outbox's count of `pos_orders` the store refused (`syncStatus: 'rejected'`), read with `pending`. Each
+   * stays until requeue() sends it again. The register outbox leaves it unset. */
+  rejected?: number;
+  sending: boolean;
+  lastRetryReason?: string;
+  nextAttemptAt?: number;
+  /** Set after 3 consecutive 401s; the app should ask the cashier to sign in, then call flush(). */
+  authRequired?: boolean;
+  /** Set when the server refused a whole batch (HTTP 400, 403, 413, 415, 422). No order is changed; sending pauses until the next flush(). */
+  refused?: { status: number; reason: string };
+  /** Set while the store (not offline) has kept failing some orders for 15 minutes, each on its own clock. Those
+   * orders stay pending and keep retrying. `orders` has each order's own entry: its `since` is when its clock
+   * would have started had there been no offline gaps (now minus its answered time; while offline, as of the
+   * moment the clock paused), and its latest `reason`. `since` is the earliest of theirs; `reason` the latest. */
+  stuck?: { commandIds: string[]; since: number; reason: string; orders: { commandId: string; since: number; reason: string }[] };
+  /** Set after 3 consecutive 404 answers (counted across the outboxes sharing one BackendNotFound): the store address
+   * may be wrong, or the store's plugin isn't installed or is switched off. The outbox keeps retrying; the next answer
+   * that isn't a 404 clears it (offline changes nothing). `since` is when the first of those 404s arrived. */
+  backendMissing?: { since: number };
+}

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

@@ -0,0 +1,175 @@
+import type { OrderCreateEnvelope } from '@tallyui/core';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import type { RxCollection, RxError } from 'rxdb';
+import { outboxLogger } from './logger';
+import { OrderContentMismatchError, sameSale, type PosOrder } from '../pos-order';
+import { watchFresh } from '../rxdb';
+import { createOrderOutbox } from './order-outbox';
+import type { CommandTransport, OutboxState } from './types';
+
+const idle: OutboxState = { pending: 0, sending: false };
+const noneStuck: readonly string[] = [];
+export { outboxLogger } from './logger';
+
+export interface UseOrderOutboxOptions {
+  /** Which order store to use (medusapos: the backend's base URL); `null` means no store. A change reopens. */
+  storeKey: string | null;
+  /** Opens the order store for `storeKey`; `close()` is called when the key or device id changes, or on unmount. */
+  open(storeKey: string): Promise<{ orders: RxCollection<PosOrder>; close(): Promise<void> }>;
+  /** Builds the command transport for `storeKey` (the app's HTTP transport and auth headers). Read once per open. */
+  transport(storeKey: string): CommandTransport<OrderCreateEnvelope>;
+  /** The device id sent on every command (see `getDeviceId`). A change reopens. */
+  deviceId: string;
+  /** Presence is fixed when the store opens; calls use the latest function. Reopen to add or remove. */
+  getMaxOrderCreateVersion?: () => number | undefined | Promise<number | undefined>;
+  /** Presence is fixed when the store opens; calls use the latest function. Reopen to add or remove. */
+  refreshCapabilities?: () => Promise<void>;
+  /** Called with `state.sending`, and with `false` on cleanup (medusapos: live-tab's `markBusy('outbox', …)`). */
+  onBusy?(busy: boolean): void;
+  /** Called when `open` rejects, even if the key has changed since (medusapos: reports storage worker failures). */
+  onOpenError?(error: unknown): void;
+}
+
+export interface UseOrderOutboxResult {
+  /** The open orders collection, or `null` until the current store is ready. */
+  orders: RxCollection<PosOrder> | null;
+  /** The outbox state, or idle until the current store is ready. */
+  state: OutboxState;
+  /** The newest 50 orders, newest first; empty until the current store is ready. */
+  recent: PosOrder[];
+  /**
+   * Stores a finalized order, then flushes. Throws the opening error, or "Orders are not ready.", before the store is ready.
+   * Recording an order whose `id` is already stored, not deleted, with the same money-bearing content (`sameSale`;
+   * a retried `complete()`) counts as stored, never overwrites it, and still flushes, whatever the stored `commandId`
+   * (a requeue mints a new one; the difference is logged at warn). Other content rejects with `OrderContentMismatchError`.
+   */
+  record(posOrder: PosOrder): Promise<void>;
+  /**
+   * Whether the current store holds this order `id`, not deleted, with the same money-bearing content (`sameSale`),
+   * whatever its `commandId`. A primary-key read on the storage instance, past RxDB's query cache. False before the
+   * store is ready; a content mismatch is false and logged at error.
+   */
+  isStored(order: PosOrder): Promise<boolean>;
+  /** Sends pending orders; does nothing before the current store is ready. */
+  flush(): Promise<void>;
+  /** Moves rejected orders back to pending (see `OrderOutbox.requeue`); resolves to 0 before the current store is ready. */
+  requeue(orderIds?: string[]): Promise<number>;
+  /**
+   * The count of `record()` calls not yet settled (resolved or rejected). An app holds sign-out
+   * (closing the store) while this is above 0, because a close that lands under a write stuck in
+   * storage can wait forever, and TallyUI deliberately doesn't bound that close (#155).
+   */
+  savesInFlight: number;
+  /** The command ids in `state.stuck`: pending orders the store keeps failing. Pass them to `needsAttention` and
+   * `OrdersList`. Empty when none, and before the current store is ready. */
+  stuckCommandIds: readonly string[];
+}
+
+/** Opens the order store for `storeKey`, runs its outbox and watches the recent orders (lifted from medusapos/app, ADR-052). */
+export function useOrderOutbox(options: UseOrderOutboxOptions): UseOrderOutboxResult {
+  const { storeKey, deviceId } = options;
+  const latest = useRef(options);
+  latest.current = options;
+  const current = useRef<{
+    storeKey: string; orders: RxCollection<PosOrder>; outbox: ReturnType<typeof createOrderOutbox>;
+  } | null>(null);
+  const openingError = useRef<unknown>(null);
+  // Order ids already logged for a content mismatch (see `isStored`), for the hook's lifetime: a hung
+  // save's poll re-asks isStored every few seconds, and a mismatch shouldn't get a fresh error each time.
+  const loggedMismatches = useRef(new Set<string>());
+  const [orders, setOrders] = useState<RxCollection<PosOrder> | null>(null);
+  const [state, setState] = useState<OutboxState>(idle);
+  const [recent, setRecent] = useState<PosOrder[]>([]);
+  const savesInFlight = useRef(0);
+  const [savesInFlightCount, setSavesInFlightCount] = useState(0);
+
+  useEffect(() => {
+    let active = true;
+    let dispose: (() => void) | undefined;
+    openingError.current = null;
+    setOrders(null); setState(idle); setRecent([]);
+    if (!storeKey) return;
+    void latest.current.open(storeKey).then(async (store) => {
+      if (!active) { await store.close(); return; }
+      const outbox = createOrderOutbox({ collection: store.orders, deviceId, transport: latest.current.transport(storeKey),
+        getMaxOrderCreateVersion: latest.current.getMaxOrderCreateVersion ? () => latest.current.getMaxOrderCreateVersion?.() : undefined,
+        refreshCapabilities: latest.current.refreshCapabilities ? async () => { await latest.current.refreshCapabilities?.(); } : undefined });
+      current.current = { storeKey, orders: store.orders, outbox };
+      const status = outbox.state$.subscribe(setState);
+      // watchFresh: find().$ can leave this stale forever, hiding a new order (RxDB 16.21.1 bug 4).
+      const history = watchFresh(store.orders, { sort: [{ createdAt: 'desc' }], limit: 50 }).subscribe(setRecent);
+      dispose = () => {
+        outbox.stop(); status.unsubscribe(); history.unsubscribe();
+        void store.close();
+      };
+      setOrders(store.orders);
+      outbox.start();
+    }).catch((error: unknown) => {
+      if (active) openingError.current = error;
+      latest.current.onOpenError?.(error);
+    });
+    return () => { active = false; current.current = null; dispose?.(); };
+  }, [storeKey, deviceId]);
+
+  useEffect(() => {
+    latest.current.onBusy?.(state.sending);
+    return () => latest.current.onBusy?.(false);
+  }, [state.sending]);
+
+  const ready = current.current?.storeKey === storeKey && !!storeKey;
+  // Each state update carries a new `stuck`; the ids keep their identity while they are unchanged.
+  const stuckKey = ready ? state.stuck?.commandIds.join(',') ?? '' : '';
+  const stuckCommandIds = useMemo(() => (stuckKey ? stuckKey.split(',') : noneStuck), [stuckKey]);
+  return { orders: ready ? orders : null, state: ready ? state : idle, recent: ready ? recent : [],
+    async flush() {
+      const opened = current.current;
+      if (opened && opened.storeKey === storeKey) await opened.outbox.flush();
+    },
+    async requeue(orderIds) {
+      const opened = current.current;
+      return opened && opened.storeKey === storeKey ? opened.outbox.requeue(orderIds) : 0;
+    },
+    savesInFlight: savesInFlightCount,
+    stuckCommandIds,
+    async record(posOrder) {
+      savesInFlight.current++;
+      setSavesInFlightCount(savesInFlight.current);
+      try {
+        const opened = current.current;
+        if (!opened || opened.storeKey !== storeKey) throw openingError.current ?? new Error('Orders are not ready.');
+        try {
+          await opened.orders.insert(posOrder);
+        } catch (error) {
+          // useSale's retry hands over the order a failed save already stored (complete() is idempotent,
+          // ADR-052). RxDB 16's insert throws RxError code 'CONFLICT' for an existing primary key, with the
+          // stored document in `parameters.writeError.documentInDb`. The same id and content means it is stored, even
+          // under another commandId: a requeue mints one, and requiring it stuck the tender on Retry (medusapos #79).
+          const stored = (error as RxError)?.code === 'CONFLICT' ? (error as RxError).parameters.writeError : undefined;
+          const inDb = stored?.status === 409 ? stored.documentInDb : undefined;
+          if (!inDb || inDb._deleted) throw error;
+          if (!sameSale(inDb, posOrder)) throw new OrderContentMismatchError(posOrder.id);
+          if (inDb.commandId !== posOrder.commandId) {
+            outboxLogger.warn('Recorded an order stored under another commandId', { orderId: posOrder.id,
+              storedCommandId: inDb.commandId, recordedCommandId: posOrder.commandId });
+          }
+        }
+        if (current.current === opened) void opened.outbox.flush();
+      } finally {
+        savesInFlight.current--;
+        setSavesInFlightCount(savesInFlight.current);
+      }
+    },
+    async isStored(order) {
+      const opened = current.current;
+      if (!opened || opened.storeKey !== storeKey) return false;
+      const [stored] = await opened.orders.storageInstance.findDocumentsById([order.id], false);
+      if (!stored || stored._deleted) return false;
+      if (sameSale(stored, order)) return true;
+      if (!loggedMismatches.current.has(order.id)) {
+        loggedMismatches.current.add(order.id);
+        outboxLogger.error('A stored order has this id with different content', { orderId: order.id });
+      }
+      return false;
+    },
+  };
+}

package/src/pos-order/__fixtures__/order-create-v3.json

@@ -0,0 +1,97 @@
+{
+  "id": "019f6d2e-7800-7000-8000-000000000001",
+  "type": "order.create",
+  "version": 3,
+  "createdAt": "2026-09-28T10:00:00.000Z",
+  "deviceId": "device_golden",
+  "attempt": 1,
+  "payload": {
+    "clientOrderId": "019f6d2e-7800-7000-8000-000000000002",
+    "createdAt": "2026-09-28T10:00:00.000Z",
+    "currency": "EUR",
+    "pricesIncludeTax": true,
+    "lines": [
+      {
+        "clientLineId": "line_inclusive",
+        "variantId": "variant_inclusive",
+        "title": "Inclusive item",
+        "quantity": 2,
+        "unitPriceMinor": 1200,
+        "discountMinor": 203
+      },
+      {
+        "clientLineId": "line_exclusive",
+        "variantId": "variant_exclusive",
+        "title": "Exclusive item",
+        "quantity": 1,
+        "unitPriceMinor": 1000,
+        "taxInclusive": false,
+        "discountMinor": 37
+      }
+    ],
+    "payments": [
+      {
+        "clientPaymentId": "payment_cash",
+        "method": "cash",
+        "amountMinor": 3256,
+        "tenderedMinor": 4000,
+        "changeMinor": 744,
+        "reference": "cash_receipt_1"
+      }
+    ],
+    "subtotalMinor": 2794,
+    "discountMinor": 240,
+    "taxMinor": 462,
+    "totalMinor": 3256,
+    "display": {
+      "currency": "EUR",
+      "exponent": 2,
+      "taxInclusive": true,
+      "subtotalMinor": 3500,
+      "discountMinor": 244,
+      "taxMinor": 462,
+      "totalMinor": 3256,
+      "lines": [
+        {
+          "clientLineId": "line_inclusive",
+          "amountMinor": 2400,
+          "discounts": [
+            {
+              "discountId": "discount_line",
+              "label": "Line discount",
+              "amountMinor": 120
+            }
+          ]
+        },
+        {
+          "clientLineId": "line_exclusive",
+          "amountMinor": 1100,
+          "discounts": []
+        }
+      ],
+      "orderDiscountMinor": 124
+    },
+    "taxByRate": [
+      {
+        "ratePpm": 200000,
+        "code": "VAT20",
+        "netMinor": 1831,
+        "taxMinor": 366,
+        "grossMinor": 2197
+      },
+      {
+        "ratePpm": 100000,
+        "netMinor": 963,
+        "taxMinor": 96,
+        "grossMinor": 1059
+      }
+    ],
+    "customer": {
+      "email": "buyer@example.com",
+      "customerId": "cus_golden_v3"
+    },
+    "registerId": "register_golden",
+    "cashierRef": "cashier_golden",
+    "sessionId": "019f6d2e-7800-7000-8000-000000000003"
+  }
+}