@teincfood/core 0.8.0 → 0.8.2

package/dist/hooks/image.hooks.d.ts

@@ -16,5 +16,9 @@ export declare const CACHED_IMAGE_KEYS: {
 };
 /** Invalidate every cached-image query (e.g. after a bulk reference sync). */
 export declare function invalidateCachedImages(queryClient: ReturnType<typeof useQueryClient>): void;
-/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+/** Resolve an image URL to a URI safe for RN `<Image>`. Prefers local cache;
+ * null for null URL AND for URIs no native loader can handle (tfimg://
+ * leaks, bare S3 keys, blob:) — callers render placeholders instead of
+ * crashing the screen. resolveImageSource passthrough is preserved for
+ * non-render consumers; this gate applies at the render boundary only. */
 export declare function useCachedImageUrl(url: string | null | undefined): string | null;

package/dist/hooks/image.hooks.js

@@ -8,7 +8,7 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useSyncExternalStore } from "react";
 import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
-import { cacheRemoteImage, getCachedImageInfo, resolveImageSource, stableCacheUrl } from "../image-cache/service";
+import { cacheRemoteImage, getCachedImageInfo, resolveImageSource, stableCacheUrl, toRenderableUri } from "../image-cache/service";
 export const IMAGE_CACHE_KEYS = {
     all: ["cachedImage"],
     url: (url) => ["cachedImage", url],
@@ -18,7 +18,11 @@ export const CACHED_IMAGE_KEYS = IMAGE_CACHE_KEYS;
 export function invalidateCachedImages(queryClient) {
     queryClient.invalidateQueries({ queryKey: IMAGE_CACHE_KEYS.all });
 }
-/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+/** Resolve an image URL to a URI safe for RN `<Image>`. Prefers local cache;
+ * null for null URL AND for URIs no native loader can handle (tfimg://
+ * leaks, bare S3 keys, blob:) — callers render placeholders instead of
+ * crashing the screen. resolveImageSource passthrough is preserved for
+ * non-render consumers; this gate applies at the render boundary only. */
 export function useCachedImageUrl(url) {
     const queryClient = useQueryClient();
     const connectivity = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
@@ -58,5 +62,5 @@ export function useCachedImageUrl(url) {
     });
     if (!enabled || !data)
         return null;
-    return data.uri;
+    return toRenderableUri(data.uri);
 }

package/dist/image-cache/service.d.ts

@@ -22,6 +22,26 @@ export declare function getCachedImageInfo(url: string): Promise<ImageCacheEntry
  * hook's warm-then-invalidate cycle into an unbounded retry storm.
  */
 export declare function isDownloadableImageUrl(url: string): boolean;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export declare function isLoadableImageUri(uri: string): boolean;
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export declare function toRenderableUri(uri: string | null | undefined): string | null;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export declare function toStorableImageUrl(value: string | null | undefined): string | null;
 export declare function cacheRemoteImage(url: string | null | undefined, opts?: {
     skipIfCached?: boolean;
     removeOnFailure?: boolean;

package/dist/image-cache/service.js

@@ -60,6 +60,42 @@ const DOWNLOADABLE_RE = /^https?:\/\//i;
 export function isDownloadableImageUrl(url) {
     return DOWNLOADABLE_RE.test(url);
 }
+const LOADABLE_RE = /^(https?|file|data|asset|content):/i;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export function isLoadableImageUri(uri) {
+    return LOADABLE_RE.test(uri);
+}
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export function toRenderableUri(uri) {
+    if (!uri)
+        return null;
+    return isLoadableImageUri(uri) ? uri : null;
+}
+const URI_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export function toStorableImageUrl(value) {
+    if (!value)
+        return null;
+    if (URI_SCHEME_RE.test(value) && !DOWNLOADABLE_RE.test(value)) {
+        syncLogger.warn("ImageCache", "Dropping un-storable image URL", { value: value.slice(0, 32) });
+        return null;
+    }
+    return value;
+}
 export async function cacheRemoteImage(url, opts = {}) {
     if (!url)
         return null;

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/reference/menu-record.js

@@ -9,6 +9,7 @@
  */
 import { generateUUID } from "../utils/uuid";
 import { CATALOG_KEYS } from "../catalog/hooks";
+import { toStorableImageUrl } from "../image-cache/service";
 export function buildMenuItemRecord(input) {
     const currencyCode = input.currencyCode || "GHS";
     const now = input.now ?? new Date().toISOString();
@@ -17,7 +18,9 @@ export function buildMenuItemRecord(input) {
         name: input.name,
         description: input.description ?? null,
         basePrice: { amountMinor: input.priceMinor, currencyCode },
-        image_url: input.imageUrl ?? null,
+        // Never persist preview URIs (tfimg:/blob:/file:): the backend stores
+        // non-http values verbatim and they poison every other device.
+        image_url: toStorableImageUrl(input.imageUrl),
         is_available: input.available ?? true,
         dietary_tags: input.dietaryTags ?? [],
         category_id: input.categoryId,
@@ -152,7 +155,9 @@ export function buildMenuItemEnvelope(input) {
                 : { name: e.name, price_minor: e.price_minor ?? 0 };
         }),
         available: input.available ?? true,
-        image_url: input.imageUrl ?? null,
+        // Same storable rule as the cache record: preview URIs must not reach
+        // the backend (it stores them verbatim).
+        image_url: toStorableImageUrl(input.imageUrl),
         ...(input.wireExtra ?? {}),
     };
     return { wire, cacheRecord };

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.0",
+  "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",