Transport layer

interface SyncTransport {
  readonly mode: 'direct' | 'hub';

  connect(): Promise<void>;
  disconnect(): void;

  // Leases
  acquireLease(posReference: string, version: number): Promise<LeaseResult>;
  releaseLease(posReference: string, finalSnapshot?: OrderSnapshotData): void;
  isLeaseHeld(posReference: string): boolean;
  onLeaseRevoked(handler: (posRef: string, reason: string) => void): () => void;

  // Orders
  sendOrderSnapshot(posReference: string, version: number, snapshot: OrderSnapshotData): void;
  onOrderUpdated(handler: (update: OrderUpdate) => void): () => void;
  onConflict(handler: (conflict: ConflictInfo) => void): () => void;
  onSyncInit(handler: (orders: SyncInitOrder[]) => void): () => void;

  // Tables
  sendTableUpdate(tableId: number, status: string, posReference?: string): void;
  onTableUpdated(handler: (update: TableUpdate) => void): () => void;

  // Floor Plan
  sendFloorPlanUpdate(floorId: number, tables: FloorPlanTableInfo[], layoutMode?: string): void;
  onFloorPlanChanged(handler: (change: FloorPlanChange) => void): () => void;

  // Table Locks
  acquireTableLock(tableId: number): Promise<TableLockResult>;
  releaseTableLock(tableId: number): void;
  forceAcquireTableLock(tableId: number): Promise<TableLockResult>;
  onTableLockRevoked(handler: (tableId: number, reason: string) => void): () => void;
  onTableLockReleased(handler: (tableId: number) => void): () => void;
  onTableLocksState(handler: (locks: TableLockInfo[]) => void): () => void;

  // Order Finalization
  finalizeOrder(posReference: string, snapshot: OrderSnapshotData, configId: number): Promise<FinalizeOrderResult>;

  // Ticket Numbers
  requestTicketNumber(orderType: "takeout" | "delivery"): Promise<string>;

  // Outbox
  queueForRetry(action: string, payload: Record<string, unknown>): void;
  flushOutbox(): Promise<{ sent: number; failed: number }>;
  getOutboxDepth(): number;

  // State
  onStateChange(handler: (state: TransportState) => void): () => void;
  getState(): TransportState;

  // Reconnection events
  onReconnecting(handler: () => void): () => void;
  onReconnected(handler: () => void): () => void;
}

type TransportState = "disconnected" | "connecting" | "connected" | "reconnecting" | "hubOffline";

function createTransport(options: CreateTransportOptions): SyncTransport {
  const hubConfig = getHubConfig(options.bootstrapConfig);
  const hubUrl = resolveHubUrl(hubConfig);

  if (hubConfig.enabled && hubUrl) {
    return createHubTransport({
      hubUrl,
      getToken: () => getStandaloneAccessToken() ?? options.token,
      deviceId: options.deviceId,
      onTokenExpired: () => refreshAccessToken(),
    });
  }

  return createDirectTransport({ sinceId, pollIntervalMs, ... });
}

sendOrderSnapshot(posRef, version, snapshot) {
  const sent = connection.send({ type: "ORDER_SNAPSHOT", ... });
  if (!sent) {
    const action = snapshot.odooId ? "orders/update" : "orders/create";
    queueOutbound(action, { pos_reference: posRef, _hubSnapshot: snapshot });
  }
}

interface HubTransportConfig {
  hubUrl: string;
  getToken: () => string;       // Called on each connect attempt
  deviceId: string;
  onTokenExpired?: () => Promise<string | null>;  // Refresh before giving up
}

nu_pos_react/src/realtime/
├── transport.ts                    # SyncTransport interface + shared types (OrderSnapshotData is the single source of truth)
├── createTransport.ts              # Factory: direct vs hub
├── directTransport.ts              # Direct-to-Odoo implementation
├── hubTransport.ts                 # Hub WebSocket implementation
├── TableLockGuard.tsx              # Renderless component for lock lifecycle
├── HubOrderBridge.tsx              # Renderless bridge: usePOS ↔ hub transport (outbound snapshots, inbound updates)
├── FloorPlanSyncBridge.tsx         # Renderless bridge: floor plan usePOS ↔ hub (order occupation sync)
├── FloorPlanStructureSyncBridge.tsx # Renderless bridge: floor plan structure changes ↔ hub
├── hub/
│   ├── hubConnection.ts            # WS lifecycle, reconnect, heartbeat
│   └── hubDiscovery.ts             # Resolve hub URL from config
├── sync/
│   ├── outbox.ts                   # localStorage outbox queue
│   ├── reconcile.ts                # Conflict reconciliation
│   ├── applyRemote.ts              # Remote event dispatcher
│   └── clock.ts                    # Logical clock (Date.now)
├── locks/
│   └── orderLocks.ts               # Local tab-level locks
└── bus/
    ├── subscribe.ts                # HTTP polling subscriber
    ├── messageTypes.ts             # Sync event types
    └── channels.ts