@teincfood/core 0.7.8 → 0.7.9

package/dist/adapters/auth.d.ts

@@ -11,3 +11,5 @@ export declare const useAuthStore: {
         user: AuthUser | null;
     };
 };
+export declare function setAuthProvider(fn: () => string | null): void;
+export declare function getAuthToken(): string | null;

package/dist/adapters/auth.js

@@ -8,3 +8,10 @@ export function setAuthUser(u) {
 export const useAuthStore = {
     getState: () => ({ user }),
 };
+let getAccessToken = null;
+export function setAuthProvider(fn) {
+    getAccessToken = fn;
+}
+export function getAuthToken() {
+    return getAccessToken ? getAccessToken() : null;
+}

package/dist/adapters/services.d.ts

@@ -40,6 +40,9 @@ export declare const sellerService: {
         data: unknown;
     }>;
     confirmHandover: (_deliveryId: string) => Promise<unknown>;
+    confirmCashPayment: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
 };
 export declare const kioskService: {
     assignKioskOrderToRider: (_orderId: string, _riderId: string) => Promise<unknown>;

package/dist/adapters/services.js

@@ -49,6 +49,9 @@ export const sellerService = {
     confirmHandover: async (_deliveryId) => {
         notImpl("sellerService.confirmHandover");
     },
+    confirmCashPayment: async (_orderId) => {
+        notImpl("sellerService.confirmCashPayment");
+    },
 };
 // kiosk.service
 export const kioskService = {

package/dist/hooks/orders.hooks.d.ts

@@ -63,6 +63,7 @@ export declare function useAssignRiderMutation(): import("@tanstack/react-query"
     orderId: string;
     riderId: string;
 }, unknown>;
+export declare function useConfirmCashPaymentMutation(): import("@tanstack/react-query").UseMutationResult<SellerOrder, Error, string, unknown>;
 export declare function useUpdateOrderStatusMutation(): {
     mutate: (orderId: string, status: string) => Promise<unknown>;
     isPending: boolean;

package/dist/hooks/orders.hooks.js

@@ -277,9 +277,13 @@ export function useSellerOrderQuery(orderId, enabled = true) {
     const businessId = useBusinessId();
     const connectivity = useConnectivity();
     const offline = isOfflineState(connectivity);
+    const pendingOrders = useCorePendingOrders(businessId);
     return useQuery({
         queryKey: SELLER_KEYS.order(orderId, businessId),
         queryFn: async () => {
+            const pendingHit = pendingOrders.find((o) => o.id === orderId || o.order_number === orderId);
+            if (pendingHit)
+                return { data: pendingHit };
             if (offline) {
                 const list = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
                 const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
@@ -295,6 +299,9 @@ export function useSellerOrderQuery(orderId, enabled = true) {
                 const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
                 if (found)
                     return { data: found };
+                const pendingAgain = getPendingOrdersSnapshot().orders.find((o) => o.id === orderId || o.order_number === orderId);
+                if (pendingAgain)
+                    return { data: pendingAgain };
                 throw e;
             }
         },
@@ -369,6 +376,23 @@ export function useAssignRiderMutation() {
         },
     });
 }
+export function useConfirmCashPaymentMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (orderId) => {
+            if (!businessId)
+                throw new Error("No active business");
+            return orderRepository.confirmCashPayment({ orderId, businessId });
+        },
+        onSettled: (_d, _e, orderId) => {
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+            if (orderId)
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) });
+        },
+    });
+}
 export function useUpdateOrderStatusMutation() {
     const accept = useAcceptOrderMutation();
     const reject = useRejectOrderMutation();

package/dist/index.d.ts

@@ -69,6 +69,7 @@ export * from "./adapters/http";
 export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
+export { setAuthProvider, getAuthToken } from "./adapters/auth";
 export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
@@ -83,6 +84,10 @@ export * from "./printer/hooks";
 export * from "./cart/store";
 export * from "./cart/hooks";
 export * from "./catalog/hooks";
+export { phoenixSocket } from "./realtime/phoenix-socket";
+export { eventsService } from "./realtime/events.service";
+export { orderEventsService } from "./realtime/order-events.service";
+export { useEventsConnection } from "./realtime/useEventsConnection";
 export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 import { type SqliteDriver } from "./adapters/sqlite";
 import { type KVDriver } from "./adapters/kv";

package/dist/index.js

@@ -72,6 +72,7 @@ export * from "./adapters/http";
 export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
+export { setAuthProvider, getAuthToken } from "./adapters/auth";
 export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
@@ -90,6 +91,11 @@ export * from "./cart/store";
 export * from "./cart/hooks";
 // ── Catalog ──
 export * from "./catalog/hooks";
+// ── Realtime (single source — PHX WebSocket + business:{id}) ──
+export { phoenixSocket } from "./realtime/phoenix-socket";
+export { eventsService } from "./realtime/events.service";
+export { orderEventsService } from "./realtime/order-events.service";
+export { useEventsConnection } from "./realtime/useEventsConnection";
 // ── Image cache (durable) ──
 export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 // ── Init helper ──

package/dist/realtime/events.service.d.ts

@@ -0,0 +1,18 @@
+type EventCallback = (event: Record<string, unknown>) => void;
+declare class EventsService {
+    private refCount;
+    private topic;
+    private joined;
+    private lastSequence;
+    private activeBusinessId;
+    private listeners;
+    private wildcardListeners;
+    private frameHandlerUnsub;
+    connect(userId: string, businessId?: string | null): () => void;
+    on(eventType: string, callback: EventCallback): () => void;
+    onAny(callback: EventCallback): () => void;
+    isConnected(): boolean;
+    resetSequence(): void;
+}
+export declare const eventsService: EventsService;
+export {};

package/dist/realtime/events.service.js

@@ -0,0 +1,76 @@
+import { phoenixSocket } from "./phoenix-socket";
+class EventsService {
+    constructor() {
+        this.refCount = 0;
+        this.topic = null;
+        this.joined = false;
+        this.lastSequence = 0;
+        this.activeBusinessId = null;
+        this.listeners = new Map();
+        this.wildcardListeners = new Set();
+        this.frameHandlerUnsub = null;
+    }
+    connect(userId, businessId) {
+        this.refCount++;
+        const topic = `events:${userId}`;
+        if (businessId !== undefined)
+            this.activeBusinessId = businessId ?? null;
+        if (this.refCount === 1 && !this.frameHandlerUnsub) {
+            this.topic = topic;
+            this.frameHandlerUnsub = phoenixSocket.onFrame(topic, ([_joinRef, _ref, _topic, event, payload]) => {
+                const data = payload;
+                const payloadBid = data?.business_id;
+                if (this.activeBusinessId && payloadBid && payloadBid !== this.activeBusinessId)
+                    return;
+                const sequence = data?._sequence;
+                if (typeof sequence === "number" && sequence <= this.lastSequence)
+                    return;
+                if (typeof sequence === "number" && sequence > this.lastSequence)
+                    this.lastSequence = sequence;
+                else if (typeof data?._sequence === "number")
+                    this.lastSequence = data._sequence;
+                const typeListeners = this.listeners.get(event);
+                if (typeListeners)
+                    typeListeners.forEach((cb) => cb(data));
+                this.wildcardListeners.forEach((cb) => cb(data));
+            });
+            const joinPayload = {};
+            if (this.lastSequence > 0)
+                joinPayload.last_sequence = this.lastSequence;
+            if (this.activeBusinessId)
+                joinPayload.business_id = this.activeBusinessId;
+            phoenixSocket.connect().then(() => phoenixSocket.joinChannel(topic, joinPayload)).then(() => { this.joined = true; }).catch(() => { });
+        }
+        else if (businessId !== undefined) {
+            // business switched while already joined — update filter without rejoin (next events filtered). If backend requires business:{id} subscription, re-join could be forced — not needed as fallback business_authorized check still passes.
+            this.activeBusinessId = businessId ?? null;
+        }
+        let disconnected = false;
+        return () => {
+            if (disconnected)
+                return;
+            disconnected = true;
+            this.refCount = Math.max(0, this.refCount - 1);
+            if (this.refCount === 0) {
+                if (this.topic && this.joined)
+                    phoenixSocket.leaveChannel(this.topic);
+                this.frameHandlerUnsub?.();
+                this.frameHandlerUnsub = null;
+                this.joined = false;
+                this.topic = null;
+                // reset sequence on full disconnect so next user doesn't dedup? Keep until next connect with same user - if user changes, lastSequence should reset. Caller should ensure new userId -> new instance or reset.
+                // Keep for replay.
+            }
+        };
+    }
+    on(eventType, callback) {
+        if (!this.listeners.has(eventType))
+            this.listeners.set(eventType, new Set());
+        this.listeners.get(eventType).add(callback);
+        return () => { this.listeners.get(eventType)?.delete(callback); };
+    }
+    onAny(callback) { this.wildcardListeners.add(callback); return () => this.wildcardListeners.delete(callback); }
+    isConnected() { return this.joined && phoenixSocket.isConnected(); }
+    resetSequence() { this.lastSequence = 0; }
+}
+export const eventsService = new EventsService();

package/dist/realtime/order-events.service.d.ts

@@ -0,0 +1,6 @@
+export declare const orderEventsService: {
+    onOrderUpdates(callback: (event: Record<string, unknown> & {
+        type: string;
+        order_id?: string;
+    }) => void): () => void;
+};

package/dist/realtime/order-events.service.js

@@ -0,0 +1,17 @@
+import { eventsService } from "./events.service";
+const ORDER_EVENT_TYPES = [
+    "order.created",
+    "order.status_changed",
+    "delivery.assigned",
+    "delivery.status_changed",
+    "delivery.pickup_confirmed",
+    "payment.completed",
+    "payment.failed",
+    "reference_data.changed",
+];
+export const orderEventsService = {
+    onOrderUpdates(callback) {
+        const unsubs = ORDER_EVENT_TYPES.map((type) => eventsService.on(type, (data) => callback({ ...data, type })));
+        return () => unsubs.forEach((fn) => fn());
+    },
+};

package/dist/realtime/phoenix-socket.d.ts

@@ -0,0 +1,55 @@
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
+export type PhoenixV2Frame = [string | null, string | null, string, string, Record<string, unknown>];
+export type PhoenixOutbound = {
+    topic: string;
+    event: string;
+    payload: Record<string, unknown>;
+    ref?: string | null;
+    joinRef?: string | null;
+};
+type FrameHandler = (frame: PhoenixV2Frame) => void;
+declare class PhoenixSocket {
+    socket: WebSocket | null;
+    private refCounter;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private heartbeatPend;
+    private heartbeatMissed;
+    private static readonly MAX_MISSED;
+    private intentionalClose;
+    private connectGen;
+    private connectPromise;
+    private connectionState;
+    private connectionListeners;
+    private pendingJoins;
+    private pendingPushes;
+    joinedChannels: Set<string>;
+    private pendingRejoin;
+    private topicJoinRefs;
+    private frameHandlers;
+    private getRef;
+    private buildSocketUrl;
+    private setState;
+    onConnectionStateChange(fn: (s: ConnectionState) => void): () => void;
+    getConnectionState(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): void;
+    retryConnection(): void;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendRaw;
+    push(topic: string, event: string, payload: Record<string, unknown>): void;
+    pushWithReply(topic: string, event: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private handleFrame;
+    onFrame(topic: string, handler: FrameHandler): () => void;
+    joinChannel(topic: string, payload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    leaveChannel(topic: string): void;
+    private rejoinPending;
+    isConnected(): boolean;
+    hasJoined(topic: string): boolean;
+}
+export declare const phoenixSocket: PhoenixSocket;
+export {};

package/dist/realtime/phoenix-socket.js

@@ -0,0 +1,240 @@
+import { WS_BASE_URL } from "../utils/constants";
+import { getAuthToken } from "../adapters/auth";
+const RECONNECT_BASE = 1000;
+const RECONNECT_MAX = 10000;
+const HEARTBEAT_MS = 30000;
+class PhoenixSocket {
+    constructor() {
+        this.socket = null;
+        this.refCounter = 0;
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.intentionalClose = false;
+        this.connectGen = 0;
+        this.connectPromise = null;
+        this.connectionState = "disconnected";
+        this.connectionListeners = new Set();
+        this.pendingJoins = new Map();
+        this.pendingPushes = new Map();
+        this.joinedChannels = new Set();
+        this.pendingRejoin = new Set();
+        this.topicJoinRefs = new Map();
+        this.frameHandlers = new Map();
+    }
+    getRef() { return String(++this.refCounter); }
+    buildSocketUrl(token) {
+        const base = WS_BASE_URL.replace(/\/+$/, "");
+        const path = base.endsWith("/ws") ? "/websocket" : "/ws/websocket";
+        return `${base}${path}?token=${encodeURIComponent(token)}&vsn=2.0.0`;
+    }
+    setState(s) {
+        this.connectionState = s;
+        this.connectionListeners.forEach((fn) => fn(s));
+    }
+    onConnectionStateChange(fn) {
+        this.connectionListeners.add(fn);
+        return () => this.connectionListeners.delete(fn);
+    }
+    getConnectionState() { return this.connectionState; }
+    connect() {
+        if (this.socket?.readyState === WebSocket.OPEN)
+            return Promise.resolve();
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.cancelReconnect();
+        this.intentionalClose = false;
+        this.setState("connecting");
+        this.connectPromise = new Promise((resolve, reject) => {
+            const token = getAuthToken();
+            if (!token) {
+                this.setState("disconnected");
+                this.connectPromise = null;
+                reject(new Error("Not authenticated"));
+                return;
+            }
+            const myGen = ++this.connectGen;
+            const url = this.buildSocketUrl(token);
+            this.socket = new WebSocket(url);
+            this.socket.onopen = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.reconnectAttempt = 0;
+                this.setState("connected");
+                this.startHeartbeat();
+                this.rejoinPending().catch(() => { });
+                this.connectPromise = null;
+                resolve();
+            };
+            this.socket.onerror = () => { if (myGen !== this.connectGen)
+                return; if (this.connectionState === "connecting") {
+                this.setState("disconnected");
+                this.connectPromise = null;
+            } };
+            this.socket.onmessage = (ev) => { try {
+                const frame = JSON.parse(ev.data);
+                this.handleFrame(frame);
+            }
+            catch { } };
+            this.socket.onclose = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.stopHeartbeat();
+                if (!this.intentionalClose) {
+                    this.joinedChannels.forEach((t) => this.pendingRejoin.add(t));
+                    this.joinedChannels.clear();
+                    this.scheduleReconnect();
+                }
+                else {
+                    this.joinedChannels.clear();
+                    this.pendingRejoin.clear();
+                    this.setState("disconnected");
+                }
+                this.connectPromise = null;
+            };
+        });
+        return this.connectPromise;
+    }
+    disconnect() {
+        this.intentionalClose = true;
+        this.cancelReconnect();
+        this.stopHeartbeat();
+        this.joinedChannels.clear();
+        this.pendingRejoin.clear();
+        this.pendingJoins.clear();
+        this.pendingPushes.clear();
+        this.topicJoinRefs.clear();
+        this.frameHandlers.clear();
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+        this.setState("disconnected");
+        this.connectPromise = null;
+    }
+    retryConnection() { this.cancelReconnect(); this.reconnectAttempt = 0; this.connect().catch(() => { }); }
+    scheduleReconnect() {
+        if (this.intentionalClose)
+            return;
+        this.setState("reconnecting");
+        const delay = Math.min(RECONNECT_BASE * Math.pow(2, this.reconnectAttempt), RECONNECT_MAX);
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => this.connect().catch(() => { }), delay);
+    }
+    cancelReconnect() { if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    } }
+    startHeartbeat() {
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.heartbeatPend) {
+                this.heartbeatMissed++;
+                if (this.heartbeatMissed >= PhoenixSocket.MAX_MISSED)
+                    this.socket?.close();
+                return;
+            }
+            this.heartbeatPend = true;
+            this.sendRaw({ topic: "phoenix", event: "heartbeat", payload: {} });
+        }, HEARTBEAT_MS);
+    }
+    stopHeartbeat() { if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+    } this.heartbeatPend = false; this.heartbeatMissed = 0; }
+    sendRaw(msg) {
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            const joinRef = msg.topic && msg.topic !== "phoenix" ? (msg.joinRef ?? this.topicJoinRefs.get(msg.topic) ?? null) : (msg.joinRef ?? null);
+            const frame = [joinRef, msg.ref ?? null, msg.topic, msg.event, msg.payload];
+            this.socket.send(JSON.stringify(frame));
+        }
+    }
+    push(topic, event, payload) { const ref = this.getRef(); this.sendRaw({ topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) }); }
+    pushWithReply(topic, event, payload) {
+        const ref = this.getRef();
+        const msg = { topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) };
+        return new Promise((resolve, reject) => {
+            this.pendingPushes.set(ref, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingPushes.has(ref)) {
+                this.pendingPushes.delete(ref);
+                reject(new Error(`Request timed out: ${event} on ${topic}`));
+            } }, 5000);
+        });
+    }
+    handleFrame([joinRef, ref, topic, event, payload]) {
+        if (event === "phx_reply" && topic === "phoenix") {
+            this.heartbeatPend = false;
+            this.heartbeatMissed = 0;
+            return;
+        }
+        if (event === "phx_reply" && ref) {
+            const pending = this.pendingPushes.get(ref);
+            if (pending) {
+                const status = payload?.status;
+                const response = (payload?.response ?? {});
+                if (status === "ok")
+                    pending.resolve(response);
+                else
+                    pending.reject(new Error(String(response.reason ?? "Request failed")));
+                this.pendingPushes.delete(ref);
+                return;
+            }
+        }
+        if (event === "phx_reply" && payload?.status === "ok") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.resolve(response);
+                this.pendingJoins.delete(topic);
+                this.joinedChannels.add(topic);
+                if (joinRef)
+                    this.topicJoinRefs.set(topic, joinRef);
+            }
+            return;
+        }
+        if (event === "phx_reply" && payload?.status === "error") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.reject(new Error(String(response.reason ?? "Join failed")));
+                this.pendingJoins.delete(topic);
+            }
+            return;
+        }
+        const handlers = this.frameHandlers.get(topic);
+        if (handlers)
+            handlers.forEach((cb) => cb([joinRef, ref, topic, event, payload]));
+    }
+    onFrame(topic, handler) {
+        if (!this.frameHandlers.has(topic))
+            this.frameHandlers.set(topic, new Set());
+        this.frameHandlers.get(topic).add(handler);
+        return () => { this.frameHandlers.get(topic)?.delete(handler); };
+    }
+    async joinChannel(topic, payload = {}) {
+        if (this.joinedChannels.has(topic))
+            return Promise.resolve({});
+        if (this.pendingJoins.has(topic))
+            return new Promise((resolve, reject) => { this.pendingJoins.set(topic, { resolve, reject }); });
+        const ref = this.getRef();
+        const msg = { topic, event: "phx_join", payload, ref };
+        return new Promise((resolve, reject) => {
+            this.pendingJoins.set(topic, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingJoins.has(topic)) {
+                this.pendingJoins.delete(topic);
+                reject(new Error(`Failed to join channel ${topic} - timeout`));
+            } }, 5000);
+        });
+    }
+    leaveChannel(topic) { this.joinedChannels.delete(topic); this.pendingRejoin.delete(topic); this.topicJoinRefs.delete(topic); }
+    async rejoinPending() { const topics = Array.from(this.pendingRejoin); this.pendingRejoin.clear(); await Promise.allSettled(topics.map((t) => this.joinChannel(t))); }
+    isConnected() { return this.socket?.readyState === WebSocket.OPEN; }
+    hasJoined(topic) { return this.joinedChannels.has(topic); }
+}
+PhoenixSocket.MAX_MISSED = 3;
+export const phoenixSocket = new PhoenixSocket();

package/dist/realtime/useEventsConnection.d.ts

@@ -0,0 +1 @@
+export declare function useEventsConnection(): void;

package/dist/realtime/useEventsConnection.js

@@ -0,0 +1,41 @@
+import { useEffect } from "react";
+import { eventsService } from "./events.service";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getAuthToken } from "../adapters/auth";
+function useBusinessId() {
+    return useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+}
+function useIsAuthenticated() {
+    // poll auth token presence; host should setAuthProvider — if no provider, assume authenticated when token exists
+    return !!getAuthToken();
+}
+export function useEventsConnection() {
+    const activeBusinessId = useBusinessId();
+    // derive userId from auth token? Host must provide via setAuthProvider that encodes user, but we need userId for topic.
+    // For now, read from global if host set it via setAuthUserId adapter. Fallback: token payload decode.
+    // Minimal: require host to call eventsService.connect with userId directly via wrapper — this hook is convenience that reads business only.
+    // To keep zero-config, we attempt to read from window localStorage token decode — fallback no-op.
+    const userId = deriveUserId();
+    useEffect(() => {
+        if (!userId)
+            return;
+        const disconnect = eventsService.connect(userId, activeBusinessId);
+        return () => disconnect();
+    }, [userId, activeBusinessId]);
+}
+function deriveUserId() {
+    try {
+        const token = getAuthToken();
+        if (!token)
+            return null;
+        const parts = token.split(".");
+        if (parts.length < 2)
+            return null;
+        const payload = JSON.parse(atob(parts[1]));
+        return payload.sub || payload.user_id || payload.id || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/reference/capabilities.js

@@ -93,6 +93,7 @@ export const CAPABILITY_BY_COMMAND = {
     "menu:update_item": "menu_manage",
     "menu:delete_item": "menu_manage",
     "menu:create_category": "menu_manage",
+    "payment:confirm_cash": "orders_accept",
 };
 export async function hasCapabilitySync(businessId, commandType) {
     const required = CAPABILITY_BY_COMMAND[commandType];

package/dist/repositories/order.repository.d.ts

@@ -41,4 +41,5 @@ export declare const orderRepository: {
     assignRider(input: AssignRiderInput & {
         businessId: string;
     }): Promise<unknown>;
+    confirmCashPayment(input: OrderActionInput): Promise<SellerOrder>;
 };

package/dist/repositories/order.repository.js

@@ -126,4 +126,13 @@ export const orderRepository = {
         }
         return event.payload;
     },
+    async confirmCashPayment(input) {
+        const command = buildCommand({
+            commandType: "payment:confirm_cash",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
 };

package/dist/sync/command-queue.service.js

@@ -25,6 +25,10 @@ const QUEUED_STATUS_BY_COMMAND = {
     "delivery:assign": "assigned",
     "delivery:confirm_handover": "delivered",
 };
+const PAYMENT_QUEUED_PAYLOAD = {
+    is_paid: true,
+    to_is_paid: true,
+};
 export function getQueuedStatus(commandType) {
     return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
 }
@@ -42,6 +46,24 @@ function buildOptimisticEvent(command) {
             timestamp: new Date().toISOString(),
         };
     }
+    if (command.command_type === "payment:confirm_cash") {
+        return {
+            event_id: generateEventId(),
+            event_type: "payment.completed_queued",
+            event_version: "1.0",
+            entity_id: command.entity_id ?? command.command_id,
+            user_id: command.user_id,
+            device_id: command.device_id,
+            payload: {
+                ...payload,
+                command_id: command.command_id,
+                is_paid: true,
+                paid_at: new Date().toISOString(),
+                order_id: command.entity_id,
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
     const queuedStatus = getQueuedStatus(command.command_type);
     return {
         event_id: generateEventId(),
@@ -58,11 +80,13 @@ function buildOptimisticEvent(command) {
             to_status: queuedStatus,
             order_id: command.entity_id,
             delivery_id: command.entity_id,
+            ...(queuedStatus ? {} : {}),
         },
         timestamp: new Date().toISOString(),
     };
 }
 function buildOptimisticOrder(command, payload) {
+    const snapshots = payload.item_snapshots ?? null;
     const items = payload.items ?? [];
     const totalMinor = payload.total_minor ?? 0;
     const subtotalMinor = payload.subtotal_minor ?? totalMinor;
@@ -109,14 +133,22 @@ function buildOptimisticOrder(command, payload) {
         delivery_lat: null,
         delivery_lng: null,
         user: null,
-        items: items.map((item, index) => ({
+        items: (snapshots ? snapshots.map((s, index) => ({
+            id: `tmp-${command.command_id}-${index}`,
+            menu_item: { id: s.menu_item_id, name: s.name },
+            quantity: s.quantity,
+            unit_price: s.unit_price_minor,
+            subtotal: s.unit_price_minor * s.quantity,
+            variant_name: s.variant_name,
+            addons: (s.addons ?? []).map((a) => ({ name: a.name, price_minor: a.price_minor })),
+        })) : items.map((item, index) => ({
             id: `tmp-${command.command_id}-${index}`,
             menu_item: { id: item.menu_item_id, name: "" },
             quantity: item.quantity,
             unit_price: 0,
             subtotal: 0,
             addons: [],
-        })),
+        }))),
         inserted_at: now,
     };
 }

package/dist/sync/order-snapshots.service.d.ts

@@ -29,6 +29,7 @@ declare class OrderSnapshotsService {
      */
     applyQueuedStatusEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
     private applyOrderStatusToReadModelInternal;
+    applyPaymentEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.

package/dist/sync/order-snapshots.service.js

@@ -97,6 +97,36 @@ class OrderSnapshotsService {
             });
         }
     }
+    async applyPaymentEvent(event, origin = "local") {
+        const payload = event.payload;
+        const orderId = payload?.order_id ?? event.entity_id;
+        if (!orderId)
+            return;
+        const paidAt = payload?.paid_at || new Date().toISOString();
+        try {
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            const lists = await getEntitySnapshotsByType(db, "seller_orders");
+            for (const list of lists) {
+                const data = list.payload.data ?? [];
+                const idx = data.findIndex((o) => o.id === orderId || o.order_number === payload?.order_number);
+                if (idx === -1)
+                    continue;
+                const updated = data.map((o, i) => i === idx ? { ...o, is_paid: true, paid_at: paidAt, payment: { ...o.payment, is_paid: true, paid_at: paidAt } } : o);
+                await upsertEntitySnapshot(db, {
+                    entityType: "seller_orders",
+                    entityId: list.entity_id,
+                    businessId: list.business_id,
+                    lastEventId: event.event_id,
+                    lastEventTimestamp: event.timestamp,
+                    payload: { ...list.payload, data: updated },
+                });
+            }
+        }
+        catch (error) {
+            syncLogger.error("OrderSnapshots", "Failed to apply payment", { error: String(error) });
+        }
+    }
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.

package/dist/sync/pending-orders.service.js

@@ -36,6 +36,7 @@ const QUEUED_STATUS_EVENT_TYPES = new Set([
     "delivery.assign_queued",
     "delivery.confirm_handover_queued",
 ]);
+const PAYMENT_QUEUED_TYPES = new Set(["payment.completed_queued"]);
 let invalidator = null;
 /**
  * Register a callback used to invalidate TanStack Query caches when a pending
@@ -99,8 +100,12 @@ export async function hydratePendingOrders() {
 export async function applyOrderStateChangeEvent(event, origin = "local") {
     try {
         const isQueued = QUEUED_STATUS_EVENT_TYPES.has(event.event_type);
-        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued)
-            return;
+        const isPaymentQueued = PAYMENT_QUEUED_TYPES.has(event.event_type);
+        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued && !isPaymentQueued) {
+            // Also handle cloud payment.completed for is_paid patch
+            if (event.event_type !== "payment.completed")
+                return;
+        }
         syncLogger.debug("OrderState", "Order state changed", {
             origin,
             event_type: event.event_type,
@@ -111,6 +116,19 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         // Queued transitions carry to_status/order_id so they patch instantly offline.
         if (isQueued) {
             await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            patchPendingStatus(event);
+            invalidator?.();
+            return;
+        }
+        if (isPaymentQueued) {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
+            invalidator?.();
+            return;
+        }
+        if (event.event_type === "payment.completed") {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
             invalidator?.();
             return;
         }
@@ -124,6 +142,46 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         });
     }
 }
+function patchPendingStatus(event) {
+    try {
+        const payload = event.payload;
+        const toStatus = payload.to_status || payload.status;
+        const orderId = payload.order_id || event.entity_id;
+        if (!toStatus || !orderId)
+            return;
+        const store = usePendingOrdersStore.getState();
+        const target = store.orders.find((o) => o.id === orderId || o.order_number === orderId);
+        if (!target)
+            return;
+        const patched = { ...target, status: toStatus };
+        store.addOrder(patched);
+    }
+    catch { }
+}
+function patchPendingPaid(event) {
+    try {
+        const payload = event.payload;
+        const orderId = payload.order_id || event.entity_id;
+        if (!orderId)
+            return;
+        const now = new Date().toISOString();
+        const store = usePendingOrdersStore.getState();
+        const target = store.orders.find((o) => o.id === orderId || o.order_number === payload.order_number || o.id === event.entity_id);
+        const altTarget = !target ? store.orders.find((o) => o.id === orderId) : null;
+        const t = target ?? altTarget;
+        if (!t)
+            return;
+        const paidAt = payload.paid_at || now;
+        const patched = {
+            ...t,
+            is_paid: true,
+            paid_at: paidAt,
+            payment: { ...t.payment, is_paid: true, paid_at: paidAt },
+        };
+        store.addOrder(patched);
+    }
+    catch { }
+}
 export async function applyPendingOrderEvent(event, origin = "local") {
     try {
         if (event.event_type === PENDING_EVENT_TYPE) {
@@ -144,6 +202,27 @@ export async function applyPendingOrderEvent(event, origin = "local") {
         if (QUEUED_STATUS_EVENT_TYPES.has(event.event_type)) {
             // Queued transitions: patch the read model so listing reflects new status offline.
             await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            // Also patch pending store so isPending overlay shows new status immediately.
+            try {
+                const payload = event.payload;
+                const toStatus = payload.to_status || payload.status;
+                const orderId = payload.order_id || event.entity_id;
+                if (toStatus && orderId) {
+                    const store = usePendingOrdersStore.getState();
+                    const target = store.orders.find((o) => o.id === orderId || o.order_number === orderId);
+                    if (target)
+                        store.addOrder({ ...target, status: toStatus });
+                }
+            }
+            catch { }
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            invalidator?.();
+            return;
+        }
+        if (PAYMENT_QUEUED_TYPES.has(event.event_type) || event.event_type === "payment.completed") {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
             const db = await openSyncDatabase();
             await insertEvent(db, { event, origin });
             invalidator?.();

package/dist/sync/transport-rest.js

@@ -50,11 +50,12 @@ export class RestTransport {
             case "order:create": {
                 const posPayload = {
                     ...payload,
+                    id: command.command_id,
                     command_id: command.command_id,
                     local_order_number: payload.order_number,
                 };
                 const response = await posService.createPOSOrder(business_id, posPayload);
-                return this.wrapResponse("order.created", response.data, entity_id, timestamp, command);
+                return this.wrapResponse("order.created", response.data, entity_id ?? command.command_id, timestamp, command);
             }
             case "order:accept": {
                 const response = await sellerService.acceptOrder(entity_id);
@@ -89,8 +90,9 @@ export class RestTransport {
                 return this.wrapResponse("delivery.status_changed", response, entity_id, timestamp, command);
             }
             case "menu:create_item": {
-                const response = await menuService.createMenuItem(business_id, payload);
-                return this.wrapResponse("menu.item_created", response, entity_id, timestamp, command);
+                const createPayload = { ...payload, id: payload.id ?? command.command_id, command_id: command.command_id };
+                const response = await menuService.createMenuItem(business_id, createPayload);
+                return this.wrapResponse("menu.item_created", response, command.command_id, timestamp, command);
             }
             case "menu:update_item": {
                 const response = await menuService.updateMenuItem(entity_id, payload);
@@ -101,8 +103,13 @@ export class RestTransport {
                 return this.wrapResponse("menu.item_deleted", response, entity_id, timestamp, command);
             }
             case "menu:create_category": {
-                const response = await menuService.createCategory(business_id, payload);
-                return this.wrapResponse("menu.category_created", response, entity_id, timestamp, command);
+                const createPayload = { ...payload, id: payload.id ?? command.command_id, command_id: command.command_id };
+                const response = await menuService.createCategory(business_id, createPayload);
+                return this.wrapResponse("menu.category_created", response, command.command_id, timestamp, command);
+            }
+            case "payment:confirm_cash": {
+                const response = await sellerService.confirmCashPayment(entity_id);
+                return this.wrapResponse("payment.completed", response, entity_id, timestamp, command);
             }
             default:
                 throw new Error(`RestTransport: unsupported command type ${command_type}`);

package/dist/sync/use-sync-reconciliation.js

@@ -10,6 +10,7 @@
 import { useEffect } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { syncEngine } from "./engine";
+import { getActiveBusiness } from "../adapters/business";
 import { applyPendingOrderEvent, applyOrderStateChangeEvent, registerPendingOrdersInvalidator, } from "./pending-orders.service";
 import { localNodeService } from "../adapters/local-node";
 import { getSyncDatabase } from "../db/connection";
@@ -24,16 +25,42 @@ function isLocalOrderEvent(event) {
     const localOrderNumber = payload.local_order_number;
     return typeof localOrderNumber === "string" && /^[0-9]{2}-[0-9]{3}-[0-9]{3}$/.test(localOrderNumber);
 }
+const RECONCILE_DEBOUNCE_MS = 400;
 export function useSyncReconciliation() {
     const queryClient = useQueryClient();
     useEffect(() => {
+        let timer;
+        const pending = new Set();
+        const flush = () => {
+            timer = undefined;
+            if (pending.has("reference")) {
+                queryClient.invalidateQueries({ queryKey: MENU_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: REFERENCE_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            }
+            if (pending.has("pending")) {
+                queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: KIOSK_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_ORDERS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: BUSINESS_DELIVERIES_KEYS.all });
+            }
+            if (pending.has("order")) {
+                // order.created with local number already covered by pending, but keep fine-grained
+                // POS.orders(businessId) is also covered by pending's broad POS.all, no extra needed.
+            }
+            pending.clear();
+        };
+        const schedule = (kind) => {
+            pending.add(kind);
+            if (!timer)
+                timer = setTimeout(flush, RECONCILE_DEBOUNCE_MS);
+        };
         // Reference changes re-sync offline data and refresh caches on this device
         // and (via the LAN relay) on every connected terminal.
         const unregisterReferenceInvalidator = registerReferenceInvalidator(() => {
-            queryClient.invalidateQueries({ queryKey: MENU_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: REFERENCE_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            schedule("reference");
         });
         // Pending-order reconciliation invalidates POS + seller order lists so the
         // server-confirmed order replaces the optimistic one. Invalidate from the
@@ -42,17 +69,21 @@ export function useSyncReconciliation() {
         // keys. Also cover kiosk/seller-orders/business-deliveries so boards
         // refresh even when there is no Local Node (offline queue + Phoenix).
         const unregisterInvalidator = registerPendingOrdersInvalidator(() => {
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: KIOSK_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_ORDERS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: BUSINESS_DELIVERIES_KEYS.all });
+            schedule("pending");
         });
         // Reference-change events are published through the Sync Engine but are
         // not backed by a command, so the engine has no transport dependency on
         // the reference module. Register the singleton once.
         registerReferenceEventEngine(syncEngine);
         const unsubscribe = syncEngine.subscribe(async (event) => {
+            // LAN strict: ignore events for other business on same subnet
+            try {
+                const activeId = getActiveBusiness()?.id;
+                const payloadBid = event.payload?.business_id;
+                if (activeId && payloadBid && payloadBid !== activeId)
+                    return;
+            }
+            catch { }
             syncLogger.event(event, "received");
             // The node relays engine events (e.g. order.created when a queued
             // command is replayed) to LAN clients so they reconcile their pending
@@ -90,15 +121,12 @@ export function useSyncReconciliation() {
                         error: String(error),
                     });
                 }
-                const payload = event.payload;
-                const businessId = payload.business_id;
-                if (businessId) {
-                    queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
-                    queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-                }
+                schedule("pending");
             }
         });
         return () => {
+            if (timer)
+                clearTimeout(timer);
             unsubscribe();
             unregisterInvalidator();
             unregisterReferenceInvalidator();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",