@teincfood/core 0.9.25 → 0.9.26

package/dist/catalog/hooks.js

@@ -73,9 +73,14 @@ export function useMenuItemsQuery(filters, enabled = true) {
         ? networkQuery.data.pages.flatMap((p) => p.data)
         : undefined;
     const data = isOnline && networkData !== undefined ? networkData : enabled ? filtered : undefined;
+    // A local snapshot (even an empty list) means the POS has something to
+    // render: never gate the whole screen on the in-flight network refresh.
+    const hasLocalSnapshot = cachedQuery.data != null;
+    const pending = cachedQuery.isPending || (!hasLocalSnapshot && networkQuery.isFetching);
     return {
         data,
-        isPending: cachedQuery.isPending && !networkData,
+        isPending: pending,
+        isLoading: pending,
         isFetching: networkQuery.isFetching,
         isError: cachedQuery.isError || networkQuery.isError,
         error: (cachedQuery.error ?? networkQuery.error),
@@ -117,10 +122,14 @@ export function useMenuCategoriesQuery() {
     const usingNetwork = isOnline && networkQuery.data;
     const data = usingNetwork ? networkQuery.data : cachedQuery.data;
     const hasCache = cachedQuery.data != null;
+    // Only report "loading" when there is nothing local to show; the network
+    // refresh must never hide an already-cached category list.
+    const pending = cachedQuery.isPending || (!hasCache && networkQuery.isFetching);
     return {
         ...networkQuery,
         data,
-        isPending: cachedQuery.isPending && !networkQuery.data,
+        isPending: pending,
+        isLoading: pending,
         isError: hasCache ? false : networkQuery.isError,
         error: hasCache ? null : networkQuery.error,
     };

package/dist/domain/orders/service.d.ts

@@ -1,7 +1,8 @@
 /**
  * Local Orders Service — SQLite is real DB (like backend Orders).
  * Device-partitioned by UUID PK + DD-RRR-CCC per business.
- * is_pos orders are accepted at create; online payment requires online.
+ * POS orders start in the business's configured flow (staged → accepted,
+ * direct → delivered); online payment requires connectivity.
  */
 import type { SellerOrder } from "../../types/api/seller.api";
 import type { POSOrderCreateRequest } from "../../types/pos.types";

package/dist/domain/orders/service.js

@@ -1,7 +1,8 @@
 /**
  * Local Orders Service — SQLite is real DB (like backend Orders).
  * Device-partitioned by UUID PK + DD-RRR-CCC per business.
- * is_pos orders are accepted at create; online payment requires online.
+ * POS orders start in the business's configured flow (staged → accepted,
+ * direct → delivered); online payment requires connectivity.
  */
 import { openSyncDatabase } from "../../db/connection";
 import { insertOrder, getOrderById, listOrders, updateOrderStatus, updateOrderPayment, getEntitySnapshotsByType } from "../../db/operations";

package/dist/hooks/startup-readiness.hooks.js

@@ -25,20 +25,38 @@ export function useStartupReadiness(options = {}) {
     const [readiness, setReadiness] = useState(null);
     const [checking, setChecking] = useState(false);
     const runRef = useRef(false);
+    // Identifies the latest readiness run so a slow catch-up for a previous
+    // business can never overwrite the verdict for the active one.
+    const tokenRef = useRef(0);
+    const businessRef = useRef(businessId);
+    // Switching business invalidates the previous verdict — its cached reference
+    // keys and lease belong to the old business.
+    useEffect(() => {
+        if (businessRef.current === businessId)
+            return;
+        businessRef.current = businessId;
+        tokenRef.current += 1;
+        runRef.current = false;
+        setReadiness(null);
+        setChecking(false);
+    }, [businessId]);
     const check = useCallback(async () => {
         if (!businessId)
             return;
         if (runRef.current)
             return;
         runRef.current = true;
+        const token = ++tokenRef.current;
         setChecking(true);
         try {
             const result = await ensureStartupReady(businessId, { timeoutMs });
-            setReadiness(result);
+            if (tokenRef.current === token)
+                setReadiness(result);
         }
         finally {
             runRef.current = false;
-            setChecking(false);
+            if (tokenRef.current === token)
+                setChecking(false);
         }
     }, [businessId, timeoutMs]);
     // First check when a business is available.

package/dist/sync/device-lease.service.js

@@ -28,8 +28,10 @@ export async function ensureLease(businessId) {
             try {
                 const leasedAt = getSync(`${LEASE_KEY(businessId)}:leased_at`);
                 const needsRefresh = !leasedAt || Date.now() - new Date(leasedAt).getTime() > LEASE_TTL_MS - 24 * 60 * 60 * 1000;
+                // Never make readiness wait on the refresh — a slow network must not
+                // hold POS startup when a valid cached lease already exists.
                 if (needsRefresh)
-                    await refreshLease(businessId);
+                    void refreshLease(businessId).catch(() => { });
             }
             catch {
                 // keep existing on any refresh failure

package/dist/sync/startup-readiness.js

@@ -77,25 +77,38 @@ export async function getStartupReadiness(businessId) {
 export async function ensureStartupReady(businessId, opts) {
     const timeoutMs = opts?.timeoutMs ?? 15000;
     const { isOnline, isCloudReachable } = getConnectivityState();
-    if (isOnline && isCloudReachable !== "unreachable") {
-        const catchUp = (async () => {
-            try {
-                await referenceSyncService.sync({ businessId, keys: [...REQUIRED_ORDER_KEYS] });
-            }
-            catch (e) {
-                syncLogger.warn("StartupReadiness", "reference catch-up failed", { err: String(e) });
-            }
-            try {
-                await ensureLease(businessId);
-            }
-            catch (e) {
-                syncLogger.warn("StartupReadiness", "lease catch-up failed", { err: String(e) });
-            }
-        })();
-        await raceWithTimeout(catchUp, timeoutMs);
+    const canUseNetwork = isOnline && isCloudReachable !== "unreachable";
+    // Evaluate the device first. If everything the POS needs is already cached,
+    // the terminal must open immediately — a slow network must never hold the
+    // seller on "Preparing offline data…". The catch-up then runs in the
+    // background and silently updates the cache.
+    const local = await getStartupReadiness(businessId);
+    if (local.ready) {
+        if (canUseNetwork)
+            void runCatchUp(businessId);
+        return local;
     }
+    // Incomplete cache: one bounded network attempt may complete it. This is the
+    // only case where waiting is useful (e.g. first launch on a new device).
+    if (canUseNetwork)
+        await raceWithTimeout(runCatchUp(businessId), timeoutMs);
     return getStartupReadiness(businessId);
 }
+/** Best-effort catch-up: reference data + device lease. Never throws. */
+async function runCatchUp(businessId) {
+    try {
+        await referenceSyncService.sync({ businessId, keys: [...REQUIRED_ORDER_KEYS] });
+    }
+    catch (e) {
+        syncLogger.warn("StartupReadiness", "reference catch-up failed", { err: String(e) });
+    }
+    try {
+        await ensureLease(businessId);
+    }
+    catch (e) {
+        syncLogger.warn("StartupReadiness", "lease catch-up failed", { err: String(e) });
+    }
+}
 /** Resolve after either the promise settles or the timeout elapses. */
 async function raceWithTimeout(promise, ms) {
     let timer;

package/package.json

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