@teincfood/core 0.8.1 → 0.8.2

package/dist/local-node/service.js

@@ -221,18 +221,42 @@ class LocalNodeServiceCore {
         return first ?? null;
     }
     broadcastToClients(event) {
-        // Mesh broadcast to all peers
+        // Mesh broadcast to all peers. Per-peer failures are LOUD (warn with
+        // peer id + error): a silent catch here once hid a full mesh blackout
+        // class of bug — peers that never receive order events never converge.
+        let delivered = 0;
+        let failed = 0;
         for (const c of this.peers.values()) {
             try {
                 c.publishEvent?.(event);
+                delivered++;
+            }
+            catch (e) {
+                failed++;
+                syncLogger.warn("LocalNodeService", "Mesh publish failed", {
+                    event_type: event.event_type,
+                    entity_id: event.entity_id,
+                    error: String(e),
+                });
             }
-            catch { }
         }
         // Also via server broadcast to connected clients
         try {
             this.server?.broadcast(event);
         }
-        catch { }
+        catch (e) {
+            syncLogger.warn("LocalNodeService", "Mesh server broadcast failed", {
+                event_type: event.event_type,
+                entity_id: event.entity_id,
+                error: String(e),
+            });
+        }
+        syncLogger.debug("LocalNodeService", "Mesh broadcast", {
+            event_type: event.event_type,
+            entity_id: event.entity_id,
+            peers: delivered,
+            failed,
+        });
     }
     setupStoreSubscriptions() {
         if (this.subscribed)
@@ -467,32 +491,69 @@ class LocalNodeServiceCore {
             secret: this.secret,
             onEvent: (event) => {
                 syncLogger.event(event, "received", { origin: "lan" });
-                if (event.event_type === "order:sync") {
+                const eventType = event.event_type;
+                // Materialize LAN order events into the canonical orders table so
+                // list queries (POS In Progress, KDS) converge without the backend.
+                // Previously only order:sync inserted rows: a cloud/local-shape
+                // order.created from a peer fell through to the pending-store apply
+                // fns (which never touch the orders table), so the event arrived,
+                // every layer reported success, and the row never materialized.
+                if (eventType === "order:sync" || eventType === "order.created" || eventType === "order.status_changed") {
                     void (async () => {
                         try {
                             const p = event.payload;
+                            const bid = deps.getBusiness()?.id;
+                            const payloadBid = p.business_id;
+                            if (typeof payloadBid === "string" && bid && payloadBid !== bid) {
+                                syncLogger.warn("LocalNodeService", "Ignoring LAN order event for another business", {
+                                    event_type: eventType,
+                                    payloadBid,
+                                    bid,
+                                });
+                                return;
+                            }
                             if (p && typeof p.order_number === "string" && p.id) {
+                                // Full-order payload (order:sync publish or order.created /
+                                // status_changed echo): upsert the canonical row. HLC guard
+                                // inside insertOrder keeps this idempotent across mesh + phx
+                                // double delivery.
                                 const db = await openSyncDatabase();
                                 await insertOrder(db, p);
+                                syncLogger.info("LocalNodeService", "LAN order row materialized", {
+                                    event_type: eventType,
+                                    order_number: p.order_number,
+                                });
                             }
                             else {
+                                // Action-shaped payload (order:sync from a LAN command):
+                                // apply the transition to the local row.
                                 const action = p.action;
-                                const orderId = p.orderId;
-                                const bid = deps.getBusiness()?.id;
+                                const orderId = p.orderId ?? p.order_id;
                                 if (action && orderId && bid) {
                                     try {
                                         await transitionLocalOrder(bid, String(orderId), action);
+                                        syncLogger.info("LocalNodeService", "LAN order transition applied", {
+                                            event_type: eventType,
+                                            action,
+                                            orderId: String(orderId),
+                                        });
                                     }
                                     catch { }
                                 }
+                                else {
+                                    syncLogger.warn("LocalNodeService", "LAN order event has no materializable payload", {
+                                        event_type: eventType,
+                                        entity_id: event.entity_id,
+                                    });
+                                }
                             }
                         }
                         catch (e) {
-                            syncLogger.debug("LocalNodeService", "LAN order:sync apply failed", { err: String(e) });
+                            syncLogger.warn("LocalNodeService", "LAN order apply failed", { err: String(e), event_type: eventType });
                         }
                         // The row is in SQLite now — invalidate so lists/detail refetch.
-                        // (order:sync bypasses the engine pipeline, so no subscriber does
-                        // this for us.)
+                        // (LAN-applied writes bypass the engine pipeline, so no
+                        // subscriber does this for us.)
                         notifyPendingOrdersChanged();
                     })();
                 }

package/dist/realtime/events.service.js

@@ -1,4 +1,5 @@
 import { phoenixSocket } from "./phoenix-socket";
+import { syncLogger } from "../utils/sync-logger";
 class EventsService {
     constructor() {
         this.refCount = 0;
@@ -29,6 +30,22 @@ class EventsService {
                     this.lastSequence = sequence;
                 else if (typeof data?._sequence === "number")
                     this.lastSequence = data._sequence;
+                // Business-state frames are LOUD (info): when live updates stall,
+                // these lines prove whether the backend pushed anything at all.
+                if (event.startsWith("order.") ||
+                    event.startsWith("delivery.") ||
+                    event.startsWith("payment.") ||
+                    event === "reference_data.changed") {
+                    try {
+                        syncLogger.info("EventsService", "Phoenix event received", {
+                            topic,
+                            event,
+                            order_id: data?.order_id ?? data?.id,
+                            business_id: payloadBid,
+                        });
+                    }
+                    catch { }
+                }
                 const typeListeners = this.listeners.get(event);
                 if (typeListeners)
                     typeListeners.forEach((cb) => cb(data));
@@ -39,7 +56,30 @@ class EventsService {
                 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(() => { });
+            phoenixSocket
+                .connect()
+                .then(() => phoenixSocket.joinChannel(topic, joinPayload))
+                .then(() => {
+                this.joined = true;
+                try {
+                    syncLogger.info("EventsService", "Phoenix channel joined", {
+                        topic,
+                        business_id: this.activeBusinessId,
+                    });
+                }
+                catch { }
+            })
+                .catch((e) => {
+                // A failed join previously vanished into a swallowed rejection:
+                // socket "connected" but subscribed to nothing. Loud from now on.
+                try {
+                    syncLogger.warn("EventsService", "Phoenix channel join failed", {
+                        topic,
+                        error: String(e),
+                    });
+                }
+                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.

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

@@ -296,10 +296,18 @@ export async function applyPendingOrderEvent(event, origin = "local") {
         }
         if (event.event_type === "order.created") {
             const payload = event.payload;
+            // Local-shape echoes carry local_order_number; cloud-shape echoes
+            // (backend id/number, e.g. received over LAN from a peer) carry only
+            // order_number. Match on either so both shapes clear the optimistic
+            // entry and converge snapshots — previously cloud-shape events hit the
+            // early return and triggered no invalidation at all.
             const localOrderNumber = payload?.local_order_number;
-            if (typeof localOrderNumber !== "string")
+            const matchNumber = typeof localOrderNumber === "string"
+                ? localOrderNumber
+                : payload?.order_number;
+            if (typeof matchNumber !== "string")
                 return;
-            usePendingOrdersStore.getState().removeByOrderNumber(localOrderNumber);
+            usePendingOrdersStore.getState().removeByOrderNumber(matchNumber);
             // Persist the cloud acknowledgment into the durable journal + read model.
             await orderSnapshotsService.persistOrderEvent(event, "cloud");
             const db = await openSyncDatabase();
@@ -313,7 +321,7 @@ export async function applyPendingOrderEvent(event, origin = "local") {
                     if (e.event_type !== PENDING_EVENT_TYPE)
                         continue;
                     if (e.payload?.order_number ===
-                        localOrderNumber) {
+                        matchNumber) {
                         ids.push(e.event_id);
                     }
                 }

package/package.json

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