The parts that are hard, and how they get solved.

// The rule that makes an offline till safe: the device writes first,
// the server converges later, and every write can be replayed.

type SaleStatus = 'pending' | 'synced' | 'failed';

async function completeSale(cart: Cart, device: DeviceId): Promise<Sale> {
  const sale: Sale = {
    id: uuid(),                    // client-generated, never server-assigned
    receiptNo: nextLocalReceipt(),
    lines: cart.lines,
    total: cart.total,
    createdAt: Date.now(),
    device,
    status: 'pending',
  };

  await local.sales.insert(sale);  // append-only; the sale exists now
  queue.enqueue({ kind: 'sale.create', id: sale.id });
  return sale;                     // the receipt prints regardless of network
}

async function drain(): Promise<void> {
  for (const job of queue.pending()) {
    try {
      // Idempotency-Key = the sale id, so a retry can never double-post.
      await api.post('/sales', await local.sales.get(job.id), {
        headers: { 'Idempotency-Key': job.id },
      });
      await local.sales.mark(job.id, 'synced');
      queue.ack(job);
    } catch (error) {
      if (isConflict(error)) {
        await reconcile(job.id);   // deterministic rules, never last-write-wins
        queue.ack(job);
        continue;
      }
      queue.backoff(job);          // exponential, capped; order preserved
    }
  }
}