@teincfood/core 0.9.23 → 0.9.25

package/dist/hooks/realtime-stubs.js

@@ -1,133 +1,38 @@
 /**
- * Realtime invalidation hooks — bridge Phoenix WebSocket events into the
- * Sync Engine so useSyncReconciliation fires and React Query caches refresh.
+ * Realtime invalidation hooks.
  *
- * Both hooks are idempotent-safe and can be called from multiple screens.
- * Invalidations are debounced: a reconnect/replay burst can deliver dozens
- * of events at once, and an immediate invalidate-per-event forces repeated
- * full re-renders of boards/grids — a major CPU spike source on low-power
- * POS hardware. Coalescing into one invalidation per ~400ms window keeps
- * the UI fresh without the render storm.
- */
-import { useEffect } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { orderEventsService } from "../realtime/order-events.service";
-import { orderSnapshotsService } from "../sync/order-snapshots.service";
-import { syncEngine } from "../sync/engine";
-import { generateEventId } from "../utils/uuid";
-import { getAppInstanceId } from "../adapters/devices";
-import { getActiveBusiness } from "../adapters/business";
-import { openSyncDatabase } from "../db/connection";
-import { getOrderById } from "../db/operations";
-const INVALIDATE_DEBOUNCE_MS = 400;
-const UNKNOWN_ORDER_PULL_DEBOUNCE_MS = 1500;
-/**
- * Subscribe to real-time order events and invalidate all queries under the
- * given root key prefix (e.g. ['seller'], ['pos'], ['kiosk']).
+ * The cloud → local event path now has a single owner: the global realtime
+ * bridge (`src/realtime/realtime-bridge.ts`), mounted once per app. It
+ * publishes every cloud event through the Sync Engine, and
+ * `useSyncReconciliation` reacts by journaling the event, patching the
+ * offline read model, invalidating the affected caches (debounced, 400 ms)
+ * and relaying the event to LAN peers.
  *
- * Each event is also persisted to the durable offline read model so order
- * history and states survive a restart while offline, and published through
- * the Sync Engine so useSyncReconciliation + LAN relay fire without polling.
+ * `useOrderRealtimeUpdates` used to be mounted per screen (POS, Orders,
+ * Kitchen, Display). That meant every mounted screen processed the same
+ * event — duplicated persistence, duplicated invalidations, duplicated
+ * fetches — and every screen that did NOT mount it (Dashboard, Settings)
+ * never saw another terminal's order at all. It is kept as a no-op so
+ * existing call sites keep compiling; new code must not use it.
  *
- * Call once per screen that needs live updates (POS, Orders, Kitchen, etc.).
+ * Invalidations stay coalesced: a reconnect/replay burst can deliver dozens
+ * of events at once, and an immediate invalidate-per-event forces repeated
+ * full re-renders of boards/grids — a major CPU spike on low-power POS
+ * hardware. One invalidation per ~400 ms window keeps the UI fresh without
+ * the render storm.
  */
-export function useOrderRealtimeUpdates(rootKey) {
-    const queryClient = useQueryClient();
-    useEffect(() => {
-        let timer;
-        const pendingOrderIds = new Set();
-        const pending = { rootKey: false };
-        const ownDeviceId = getAppInstanceId();
-        const flush = () => {
-            timer = undefined;
-            if (pending.rootKey)
-                queryClient.invalidateQueries({ queryKey: rootKey });
-            for (const oid of pendingOrderIds) {
-                queryClient.invalidateQueries({ queryKey: [...rootKey, "order", oid] });
-            }
-            pendingOrderIds.clear();
-            pending.rootKey = false;
-        };
-        const unsub = orderEventsService.onOrderUpdates((event) => {
-            pending.rootKey = true;
-            if (event.order_id)
-                pendingOrderIds.add(event.order_id);
-            const payload = { ...event };
-            // Delivery events carry no business_id — the socket already filtered by
-            // business, so stamp the active one for read-model patching.
-            if (!payload.business_id && !payload.businessId) {
-                try {
-                    const bid = getActiveBusiness()?.id;
-                    if (bid)
-                        payload.business_id = bid;
-                }
-                catch { }
-            }
-            const domainEvent = {
-                event_id: payload.event_id ?? generateEventId(),
-                event_type: event.type,
-                event_version: payload.event_version ?? "1.0",
-                timestamp: payload.timestamp ?? new Date().toISOString(),
-                device_id: payload.device_id ?? ownDeviceId,
-                user_id: payload.user_id ?? "system",
-                entity_id: event.order_id ?? "",
-                payload,
-            };
-            // Persist to durable offline read model (entity_snapshots table).
-            orderSnapshotsService.persistOrderEvent(domainEvent, "cloud").catch(() => { });
-            // order.created from another terminal is summary-only (no full body):
-            // invalidate alone can't surface it because SQLite has no row. Pull
-            // once (debounced) when the order is unknown locally. Event-driven —
-            // no polling.
-            if (event.type === "order.created" && event.order_id) {
-                const bid = payload.business_id;
-                if (bid) {
-                    void (async () => {
-                        try {
-                            const db = await openSyncDatabase();
-                            const known = await getOrderById(db, bid, event.order_id);
-                            if (!known)
-                                scheduleUnknownOrderPull(bid);
-                        }
-                        catch { }
-                    })();
-                }
-            }
-            // Publish through the Sync Engine so useSyncReconciliation + LAN relay
-            // fire without waiting for the next poll.
-            try {
-                syncEngine.publish(domainEvent);
-            }
-            catch { }
-            if (!timer)
-                timer = setTimeout(flush, INVALIDATE_DEBOUNCE_MS);
-        });
-        return () => {
-            if (timer)
-                clearTimeout(timer);
-            unsub();
-        };
-    }, [queryClient, rootKey]);
-}
+import { useGlobalRealtimeBridge } from "../realtime/realtime-bridge";
 /**
- * Debounced pull for remotely-created orders (one timer per business).
- * Module-level so bursts across screens coalesce into a single pull.
+ * @deprecated Mount the global bridge once at the app root instead
+ * (`useRealtimeInvalidation` or `useSyncReconciliation`). Kept as a no-op
+ * so legacy call sites remain source-compatible.
  */
-const unknownOrderPullTimers = new Map();
-function scheduleUnknownOrderPull(businessId) {
-    if (unknownOrderPullTimers.has(businessId))
-        return;
-    const t = setTimeout(() => {
-        unknownOrderPullTimers.delete(businessId);
-        void import("../sync/sync-jobs.service")
-            .then((m) => m.pullRemoteOrders(businessId))
-            .catch(() => { });
-    }, UNKNOWN_ORDER_PULL_DEBOUNCE_MS);
-    unknownOrderPullTimers.set(businessId, t);
-}
+export function useOrderRealtimeUpdates(_rootKey) { }
 /**
- * Global realtime invalidation — currently handled entirely by
- * useOrderRealtimeUpdates + useSyncReconciliation. Kept as a no-op for
- * backward compatibility with any lingering call sites.
+ * Global realtime invalidation — mounts the single app-wide Phoenix
+ * subscription. Pair with `useSyncReconciliation` (which reacts to the
+ * published events) at the app root.
  */
-export function useRealtimeInvalidation() { }
+export function useRealtimeInvalidation() {
+    useGlobalRealtimeBridge();
+}

package/dist/index.d.ts

@@ -44,6 +44,7 @@ export { createAppQueryClient, createQueryPersister } from "./providers/query-cl
 export { useSellerAnalyticsQuery } from "./hooks/analytics.hooks";
 export { useSellerDashboardQuery } from "./hooks/dashboard.hooks";
 export { useRealtimeInvalidation, useOrderRealtimeUpdates } from "./hooks/realtime-stubs";
+export { useGlobalRealtimeBridge, subscribeGlobalRealtime } from "./realtime/realtime-bridge";
 export { useAcceptFleetInvitationMutation, useAcceptBusinessInvitationMutation, useUserInvitationsQuery, } from "./hooks/members.hooks";
 export { useJoinRequestsQuery } from "./hooks/fleet.hooks";
 export * from "./db/migrations";
@@ -143,6 +144,7 @@ export * from "./sync/transition-endpoints";
 export * from "./utils/business-hours";
 export * from "./hooks/business-hours.hooks";
 export * from "./domain/orders/service";
+export * from "./domain/orders/order-flow";
 export * from "./domain/orders/snapshots";
 export { phoenixSocket } from "./realtime/phoenix-socket";
 export { eventsService } from "./realtime/events.service";

package/dist/index.js

@@ -44,6 +44,7 @@ export { createAppQueryClient, createQueryPersister } from "./providers/query-cl
 export { useSellerAnalyticsQuery } from "./hooks/analytics.hooks";
 export { useSellerDashboardQuery } from "./hooks/dashboard.hooks";
 export { useRealtimeInvalidation, useOrderRealtimeUpdates } from "./hooks/realtime-stubs";
+export { useGlobalRealtimeBridge, subscribeGlobalRealtime } from "./realtime/realtime-bridge";
 export { useAcceptFleetInvitationMutation, useAcceptBusinessInvitationMutation, useUserInvitationsQuery, } from "./hooks/members.hooks";
 export { useJoinRequestsQuery } from "./hooks/fleet.hooks";
 // ── DB ──
@@ -155,6 +156,7 @@ export * from "./hooks/business-hours.hooks";
 // components/OrderStatusCard was folded into order-transitions (compat re-export lives in apps)
 // ── Domain (offline-first primary DB) ──
 export * from "./domain/orders/service";
+export * from "./domain/orders/order-flow";
 export * from "./domain/orders/snapshots";
 // ── Realtime (single source — PHX WebSocket + business:{id}) ──
 export { phoenixSocket } from "./realtime/phoenix-socket";

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

@@ -3,11 +3,20 @@ declare class EventsService {
     private refCount;
     private topic;
     private joined;
+    /**
+     * Last event sequence per business. The backend sequence is global, but the
+     * watermark is kept per business so switching business (or account) never
+     * inherits — and therefore never skips — the other scope's events.
+     */
+    private sequences;
     private lastSequence;
     private activeBusinessId;
+    private activeUserId;
     private listeners;
     private wildcardListeners;
     private frameHandlerUnsub;
+    private currentSequence;
+    private setCurrentSequence;
     connect(userId: string, businessId?: string | null): () => void;
     on(eventType: string, callback: EventCallback): () => void;
     onAny(callback: EventCallback): () => void;

package/dist/realtime/events.service.js

@@ -5,12 +5,30 @@ class EventsService {
         this.refCount = 0;
         this.topic = null;
         this.joined = false;
+        /**
+         * Last event sequence per business. The backend sequence is global, but the
+         * watermark is kept per business so switching business (or account) never
+         * inherits — and therefore never skips — the other scope's events.
+         */
+        this.sequences = new Map();
         this.lastSequence = 0;
         this.activeBusinessId = null;
+        this.activeUserId = null;
         this.listeners = new Map();
         this.wildcardListeners = new Set();
         this.frameHandlerUnsub = null;
     }
+    currentSequence() {
+        if (this.activeBusinessId)
+            return this.sequences.get(this.activeBusinessId) ?? 0;
+        return this.lastSequence;
+    }
+    setCurrentSequence(sequence) {
+        if (this.activeBusinessId)
+            this.sequences.set(this.activeBusinessId, sequence);
+        else
+            this.lastSequence = sequence;
+    }
     connect(userId, businessId) {
         this.refCount++;
         const topic = `events:${userId}`;
@@ -18,18 +36,26 @@ class EventsService {
             this.activeBusinessId = businessId ?? null;
         if (this.refCount === 1 && !this.frameHandlerUnsub) {
             this.topic = topic;
+            // A different account has a different authorization scope: sequences
+            // from the previous account are not comparable, so start clean.
+            if (this.activeUserId !== userId) {
+                this.activeUserId = userId;
+                this.sequences.clear();
+                this.lastSequence = 0;
+            }
             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)
+                const last = this.currentSequence();
+                if (typeof sequence === "number" && sequence <= last)
                     return;
-                if (typeof sequence === "number" && sequence > this.lastSequence)
-                    this.lastSequence = sequence;
+                if (typeof sequence === "number")
+                    this.setCurrentSequence(sequence);
                 else if (typeof data?._sequence === "number")
-                    this.lastSequence = data._sequence;
+                    this.setCurrentSequence(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.") ||
@@ -52,8 +78,9 @@ class EventsService {
                 this.wildcardListeners.forEach((cb) => cb(data));
             });
             const joinPayload = {};
-            if (this.lastSequence > 0)
-                joinPayload.last_sequence = this.lastSequence;
+            const joinSequence = this.currentSequence();
+            if (joinSequence > 0)
+                joinPayload.last_sequence = joinSequence;
             if (this.activeBusinessId)
                 joinPayload.business_id = this.activeBusinessId;
             phoenixSocket
@@ -111,6 +138,9 @@ class EventsService {
     }
     onAny(callback) { this.wildcardListeners.add(callback); return () => this.wildcardListeners.delete(callback); }
     isConnected() { return this.joined && phoenixSocket.isConnected(); }
-    resetSequence() { this.lastSequence = 0; }
+    resetSequence() {
+        this.lastSequence = 0;
+        this.sequences.clear();
+    }
 }
 export const eventsService = new EventsService();

package/dist/realtime/realtime-bridge.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Global realtime bridge — ONE Phoenix subscription for the whole app.
+ *
+ * Before this module existed, cloud events were only processed by screens
+ * that mounted `useOrderRealtimeUpdates` (POS, Orders, Kitchen, Display).
+ * Any other screen — the Dashboard, Settings, the business switcher — never
+ * saw another terminal's order, and every mounted screen duplicated the
+ * same handling (one persist + publish + invalidate per screen).
+ *
+ * The bridge is the single owner of the cloud → local event path:
+ *
+ *   Phoenix frame
+ *     → orderEventsService (typed event fan-out)
+ *       → business filter (active business only)
+ *         → syncEngine.publish(domainEvent)
+ *             → useSyncReconciliation: journal + read-model patch +
+ *               debounced query invalidation (+ LAN relay for mesh peers)
+ *         → unknown `order.created` → fetch THAT order only
+ *
+ * Mounting it from several hooks is safe: the underlying subscription is
+ * created once and torn down when the last consumer unmounts.
+ */
+/**
+ * Subscribe to the global realtime bridge.
+ * Safe to call from multiple hooks — the underlying socket listener is
+ * created once and disposed when the last caller releases it.
+ */
+export declare function subscribeGlobalRealtime(): () => void;
+/** React hook wrapper around `subscribeGlobalRealtime`. */
+export declare function useGlobalRealtimeBridge(): void;

package/dist/realtime/realtime-bridge.js

@@ -0,0 +1,149 @@
+/**
+ * Global realtime bridge — ONE Phoenix subscription for the whole app.
+ *
+ * Before this module existed, cloud events were only processed by screens
+ * that mounted `useOrderRealtimeUpdates` (POS, Orders, Kitchen, Display).
+ * Any other screen — the Dashboard, Settings, the business switcher — never
+ * saw another terminal's order, and every mounted screen duplicated the
+ * same handling (one persist + publish + invalidate per screen).
+ *
+ * The bridge is the single owner of the cloud → local event path:
+ *
+ *   Phoenix frame
+ *     → orderEventsService (typed event fan-out)
+ *       → business filter (active business only)
+ *         → syncEngine.publish(domainEvent)
+ *             → useSyncReconciliation: journal + read-model patch +
+ *               debounced query invalidation (+ LAN relay for mesh peers)
+ *         → unknown `order.created` → fetch THAT order only
+ *
+ * Mounting it from several hooks is safe: the underlying subscription is
+ * created once and torn down when the last consumer unmounts.
+ */
+import { useEffect } from "react";
+import { orderEventsService } from "./order-events.service";
+import { syncEngine } from "../sync/engine";
+import { getActiveBusiness } from "../adapters/business";
+import { getAppInstanceId } from "../adapters/devices";
+import { generateEventId } from "../utils/uuid";
+import { openSyncDatabase } from "../db/connection";
+import { getOrderById } from "../db/operations";
+import { fetchRemoteOrderByNumber } from "../sync/sync-jobs.service";
+import { syncLogger } from "../utils/sync-logger";
+/** Coalesce bursts of `order.created` events into one fetch per order. */
+const UNKNOWN_ORDER_FETCH_DEBOUNCE_MS = 400;
+let consumerCount = 0;
+let detach = null;
+/**
+ * Subscribe to the global realtime bridge.
+ * Safe to call from multiple hooks — the underlying socket listener is
+ * created once and disposed when the last caller releases it.
+ */
+export function subscribeGlobalRealtime() {
+    consumerCount += 1;
+    if (!detach)
+        detach = attachBridge();
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        consumerCount -= 1;
+        if (consumerCount <= 0) {
+            consumerCount = 0;
+            try {
+                detach?.();
+            }
+            catch { }
+            detach = null;
+        }
+    };
+}
+/** React hook wrapper around `subscribeGlobalRealtime`. */
+export function useGlobalRealtimeBridge() {
+    useEffect(() => subscribeGlobalRealtime(), []);
+}
+function attachBridge() {
+    const pendingFetches = new Map();
+    const scheduleUnknownOrderFetch = (businessId, orderNumber, orderId) => {
+        if (!businessId || (!orderNumber && !orderId))
+            return;
+        const key = `${businessId}:${orderNumber ?? orderId}`;
+        if (pendingFetches.has(key))
+            return;
+        const timer = setTimeout(() => {
+            pendingFetches.delete(key);
+            void (async () => {
+                try {
+                    // Only fetch when this device has never seen the order — the
+                    // realtime payload is summary-only, so a known order needs no
+                    // network call at all.
+                    if (orderId) {
+                        const db = await openSyncDatabase();
+                        const known = await getOrderById(db, businessId, orderId);
+                        if (known)
+                            return;
+                    }
+                    if (!orderNumber)
+                        return;
+                    await fetchRemoteOrderByNumber(businessId, orderNumber);
+                }
+                catch { }
+            })();
+        }, UNKNOWN_ORDER_FETCH_DEBOUNCE_MS);
+        pendingFetches.set(key, timer);
+    };
+    const unsubscribe = orderEventsService.onOrderUpdates((event) => {
+        try {
+            const payload = { ...event };
+            const activeBusinessId = getActiveBusiness()?.id;
+            let businessId = payload.business_id ??
+                payload.businessId;
+            // Delivery events carry no business id — the socket already filtered by
+            // business, so stamp the active one for read-model patching.
+            if (!businessId && activeBusinessId) {
+                businessId = activeBusinessId;
+                payload.business_id = activeBusinessId;
+            }
+            if (!businessId)
+                return;
+            // Never let another business' event touch this device.
+            if (activeBusinessId && businessId !== activeBusinessId)
+                return;
+            const ownDeviceId = getAppInstanceId();
+            const domainEvent = {
+                event_id: payload.event_id ?? generateEventId(),
+                event_type: event.type,
+                event_version: payload.event_version ?? "1.0",
+                timestamp: payload.timestamp ?? new Date().toISOString(),
+                device_id: payload.device_id ?? ownDeviceId,
+                user_id: payload.user_id ?? "system",
+                entity_id: event.order_id ?? "",
+                payload,
+                origin: "cloud",
+            };
+            // Publish through the Sync Engine: the reconciliation bridge journals
+            // the event, patches the offline read model, invalidates the caches and
+            // relays the event to LAN peers.
+            syncEngine.publish(domainEvent);
+            // An order created on another terminal arrives as a summary only, so
+            // this device has no row for it — fetch that single order (not the
+            // whole list) so the board fills in.
+            if (event.type === "order.created") {
+                scheduleUnknownOrderFetch(businessId, payload.order_number ??
+                    payload.local_order_number, event.order_id);
+            }
+        }
+        catch (error) {
+            syncLogger.warn("RealtimeBridge", "Failed to handle cloud event", {
+                error: String(error),
+            });
+        }
+    });
+    return () => {
+        for (const timer of pendingFetches.values())
+            clearTimeout(timer);
+        pendingFetches.clear();
+        unsubscribe();
+    };
+}

package/dist/reference/events.d.ts

@@ -45,7 +45,7 @@ export declare function emitReferenceChanged(businessId: string, keys: Reference
  * by a single-flight flag. Errors are logged, never thrown, so a failed
  * reference sync can never crash the LAN event loop.
  */
-export declare function applyReferenceChangeEvent(event: DomainEvent, origin?: "local" | "lan"): Promise<void>;
+export declare function applyReferenceChangeEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
 /**
  * Best-effort reference data sync when connectivity recovers. Covers devices
  * that missed the change event (offline, not on the LAN) — the next time they

package/dist/reference/service.d.ts

@@ -9,8 +9,17 @@
  */
 import type { ReferenceDataKey, ReferenceSyncOptions, ReferenceSyncResult, ReferenceDataRecord } from "./types";
 declare class ReferenceSyncService {
-    private isSyncing;
+    /** Single-flight per business (a global flag made a business switch skip its sync). */
+    private inflight;
+    /**
+     * Keys requested while a pass was already running for that business.
+     * They used to be dropped, which meant a menu edit could land while
+     * another reference sync was in flight and never be fetched.
+     */
+    private queued;
     sync(options: ReferenceSyncOptions): Promise<ReferenceSyncResult>;
+    private rememberRequest;
+    private runSync;
     private syncKey;
     private fetchFallback;
     /**

package/dist/reference/service.js

@@ -38,12 +38,20 @@ const DEFAULT_SYNC_KEYS = [
 ];
 class ReferenceSyncService {
     constructor() {
-        this.isSyncing = false;
+        /** Single-flight per business (a global flag made a business switch skip its sync). */
+        this.inflight = new Map();
+        /**
+         * Keys requested while a pass was already running for that business.
+         * They used to be dropped, which meant a menu edit could land while
+         * another reference sync was in flight and never be fetched.
+         */
+        this.queued = new Map();
     }
     async sync(options) {
-        if (!canBusinessSync(options.businessId)) {
+        const businessId = options.businessId;
+        if (!canBusinessSync(businessId)) {
             syncLogger.debug("ReferenceSync", "Skipping sync — no business/auth", {
-                businessId: options.businessId,
+                businessId,
             });
             return {
                 synced: [],
@@ -52,18 +60,71 @@ class ReferenceSyncService {
                 errors: {},
             };
         }
-        if (this.isSyncing) {
-            return {
-                synced: [],
-                skipped: [],
-                failed: [],
-                errors: {},
-            };
+        const running = this.inflight.get(businessId);
+        if (running) {
+            // Remember the request so it is not lost, then wait for the pass that
+            // is already running.
+            this.rememberRequest(businessId, options.keys);
+            try {
+                return await running;
+            }
+            catch {
+                return { synced: [], skipped: [], failed: [], errors: {} };
+            }
+        }
+        const pass = (async () => {
+            try {
+                return await this.runSync(options);
+            }
+            finally {
+                this.inflight.delete(businessId);
+            }
+        })();
+        this.inflight.set(businessId, pass);
+        let result;
+        try {
+            result = await pass;
+        }
+        catch (error) {
+            syncLogger.warn("ReferenceSync", "Sync pass failed", { businessId, error: String(error) });
+            result = { synced: [], skipped: [], failed: [], errors: {} };
+        }
+        // Requests that arrived during the pass are served by one follow-up
+        // pass — never silently dropped.
+        const queued = this.queued.get(businessId);
+        if (queued && queued.size > 0) {
+            this.queued.delete(businessId);
+            const wantsAll = queued.has("*");
+            const keys = Array.from(queued).filter((k) => k !== "*");
+            const followUp = wantsAll
+                ? { businessId }
+                : { businessId, keys, incremental: true };
+            syncLogger.info("ReferenceSync", "Running follow-up pass for queued keys", {
+                businessId,
+                all: wantsAll,
+                keys,
+            });
+            await this.sync(followUp).catch(() => undefined);
+        }
+        return result;
+    }
+    rememberRequest(businessId, keys) {
+        const set = this.queued.get(businessId) ?? new Set();
+        if (!keys || keys.length === 0) {
+            set.add("*");
         }
+        else {
+            for (const key of keys)
+                set.add(key);
+        }
+        this.queued.set(businessId, set);
+    }
+    async runSync(options) {
+        const businessId = options.businessId;
         const { isOnline, isCloudReachable } = getConnectivityState();
         if (!isOnline || isCloudReachable === "unreachable") {
             syncLogger.debug("ReferenceSync", "Skipping sync — cloud not reachable", {
-                businessId: options.businessId,
+                businessId,
                 isOnline,
                 isCloudReachable,
             });
@@ -74,9 +135,8 @@ class ReferenceSyncService {
                 errors: {},
             };
         }
-        this.isSyncing = true;
         syncLogger.info("ReferenceSync", "Starting reference data sync", {
-            businessId: options.businessId,
+            businessId,
             keys: options.keys,
         });
         const result = {
@@ -145,13 +205,13 @@ class ReferenceSyncService {
             }
         }
         finally {
-            this.isSyncing = false;
+            syncLogger.info("ReferenceSync", "Reference data sync complete", {
+                businessId,
+                synced: result.synced,
+                skipped: result.skipped,
+                failed: result.failed,
+            });
         }
-        syncLogger.info("ReferenceSync", "Reference data sync complete", {
-            synced: result.synced,
-            skipped: result.skipped,
-            failed: result.failed,
-        });
         return result;
     }
     async syncKey(db, key, options, versions) {