@teincfood/core 0.1.1 → 0.1.2

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Durable order read-model.
  *
@@ -14,11 +13,9 @@
  *   2. Successful order list fetches are written through as snapshots so the
  *      exact list last seen while online is available offline.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderSnapshotsService = void 0;
-const connection_1 = require("../db/connection");
-const operations_1 = require("../db/operations");
-const sync_logger_1 = require("../utils/sync-logger");
+import { openSyncDatabase } from "../db/connection";
+import { insertEvent, upsertEntitySnapshot, getEntitySnapshot, getEntitySnapshotsByType, pruneEntitySnapshots, } from "../db/operations";
+import { syncLogger } from "../utils/sync-logger";
 const RETAIN_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const ORDER_EVENT_TYPES = new Set([
     "order.created",
@@ -39,13 +36,13 @@ class OrderSnapshotsService {
         if (!ORDER_EVENT_TYPES.has(event.event_type))
             return false;
         try {
-            const db = await (0, connection_1.openSyncDatabase)();
-            await (0, operations_1.insertEvent)(db, { event, origin });
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
             await this.applyOrderStatusToReadModel(db, event);
             return true;
         }
         catch (error) {
-            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to persist order event", {
+            syncLogger.error("OrderSnapshots", "Failed to persist order event", {
                 error: String(error),
                 event_type: event.event_type,
             });
@@ -65,14 +62,14 @@ class OrderSnapshotsService {
             return;
         }
         try {
-            const lists = await (0, operations_1.getEntitySnapshotsByType)(db, "seller_orders");
+            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);
                 if (idx === -1)
                     continue;
                 const updated = data.map((o, i) => i === idx ? { ...o, status: toStatus } : o);
-                await (0, operations_1.upsertEntitySnapshot)(db, {
+                await upsertEntitySnapshot(db, {
                     entityType: "seller_orders",
                     entityId: list.entity_id,
                     businessId: list.business_id,
@@ -83,7 +80,7 @@ class OrderSnapshotsService {
             }
         }
         catch (error) {
-            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to apply status to read model", {
+            syncLogger.error("OrderSnapshots", "Failed to apply status to read model", {
                 error: String(error),
             });
         }
@@ -97,8 +94,8 @@ class OrderSnapshotsService {
         if (!businessId)
             return;
         try {
-            const db = await (0, connection_1.openSyncDatabase)();
-            await (0, operations_1.upsertEntitySnapshot)(db, {
+            const db = await openSyncDatabase();
+            await upsertEntitySnapshot(db, {
                 entityType: "seller_orders",
                 entityId: scope,
                 businessId,
@@ -108,7 +105,7 @@ class OrderSnapshotsService {
             });
         }
         catch (error) {
-            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to persist seller list", {
+            syncLogger.error("OrderSnapshots", "Failed to persist seller list", {
                 error: String(error),
                 businessId,
             });
@@ -119,14 +116,14 @@ class OrderSnapshotsService {
      */
     async getSellerList(businessId, scope) {
         try {
-            const db = await (0, connection_1.openSyncDatabase)();
-            const snap = await (0, operations_1.getEntitySnapshot)(db, "seller_orders", scope);
+            const db = await openSyncDatabase();
+            const snap = await getEntitySnapshot(db, "seller_orders", scope);
             if (!snap || snap.business_id !== businessId)
                 return null;
             return snap.payload.data ?? null;
         }
         catch (error) {
-            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to read seller list", {
+            syncLogger.error("OrderSnapshots", "Failed to read seller list", {
                 error: String(error),
             });
             return null;
@@ -138,14 +135,14 @@ class OrderSnapshotsService {
     async pruneOld() {
         try {
             const cutoff = new Date(Date.now() - RETAIN_MS).toISOString();
-            const db = await (0, connection_1.openSyncDatabase)();
-            await (0, operations_1.pruneEntitySnapshots)(db, "seller_orders", cutoff);
+            const db = await openSyncDatabase();
+            await pruneEntitySnapshots(db, "seller_orders", cutoff);
         }
         catch (error) {
-            sync_logger_1.syncLogger.error("OrderSnapshots", "Failed to prune", {
+            syncLogger.error("OrderSnapshots", "Failed to prune", {
                 error: String(error),
             });
         }
     }
 }
-exports.orderSnapshotsService = new OrderSnapshotsService();
+export const orderSnapshotsService = new OrderSnapshotsService();

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Pending Orders Service.
  *
@@ -15,16 +14,11 @@
  * itself; `order.created` carries `local_order_number` matching the optimistic
  * order's `order_number`.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPendingOrdersInvalidator = registerPendingOrdersInvalidator;
-exports.hydratePendingOrders = hydratePendingOrders;
-exports.applyOrderStateChangeEvent = applyOrderStateChangeEvent;
-exports.applyPendingOrderEvent = applyPendingOrderEvent;
-const connection_1 = require("../db/connection");
-const operations_1 = require("../db/operations");
-const pending_orders_1 = require("../adapters/pending-orders");
-const order_snapshots_service_1 = require("./order-snapshots.service");
-const sync_logger_1 = require("../utils/sync-logger");
+import { openSyncDatabase } from "../db/connection";
+import { insertEvent, getUnsyncedEvents, markEventsSynced, } from "../db/operations";
+import { usePendingOrdersStore } from "../adapters/pending-orders";
+import { orderSnapshotsService } from "./order-snapshots.service";
+import { syncLogger } from "../utils/sync-logger";
 const PENDING_EVENT_TYPE = "order.create_queued";
 /** Order/delivery state-change events that should refresh every terminal. */
 const ORDER_STATE_EVENT_TYPES = new Set([
@@ -37,7 +31,7 @@ let invalidator = null;
  * Register a callback used to invalidate TanStack Query caches when a pending
  * order is reconciled. Returns an unregister function.
  */
-function registerPendingOrdersInvalidator(fn) {
+export function registerPendingOrdersInvalidator(fn) {
     invalidator = fn;
     return () => {
         if (invalidator === fn)
@@ -48,15 +42,15 @@ function registerPendingOrdersInvalidator(fn) {
  * Load persisted unsynced order:create_queued events into the store.
  * Idempotent; safe to call after app restart while still offline.
  */
-async function hydratePendingOrders() {
-    const store = pending_orders_1.usePendingOrdersStore.getState();
+export async function hydratePendingOrders() {
+    const store = usePendingOrdersStore.getState();
     if (store.hydrated)
         return;
     try {
-        const db = await (0, connection_1.openSyncDatabase)();
+        const db = await openSyncDatabase();
         const byNumber = new Map();
         for (const origin of ["local", "lan"]) {
-            const events = await (0, operations_1.getUnsyncedEvents)(db, origin, Number.MAX_SAFE_INTEGER);
+            const events = await getUnsyncedEvents(db, origin, Number.MAX_SAFE_INTEGER);
             for (const event of events) {
                 if (event.event_type !== PENDING_EVENT_TYPE)
                     continue;
@@ -65,15 +59,15 @@ async function hydratePendingOrders() {
                     byNumber.set(order.order_number, order);
             }
         }
-        pending_orders_1.usePendingOrdersStore.setState({ orders: [...byNumber.values()] });
+        usePendingOrdersStore.setState({ orders: [...byNumber.values()] });
     }
     catch (error) {
-        sync_logger_1.syncLogger.error("PendingOrders", "Hydration failed", {
+        syncLogger.error("PendingOrders", "Hydration failed", {
             error: String(error),
         });
     }
     finally {
-        pending_orders_1.usePendingOrdersStore.getState().setHydrated(true);
+        usePendingOrdersStore.getState().setHydrated(true);
     }
 }
 /**
@@ -92,36 +86,36 @@ async function hydratePendingOrders() {
  * pending-orders store (only queued creations are); this only fires the
  * invalidator. Idempotent — duplicate deliveries are harmless.
  */
-async function applyOrderStateChangeEvent(event, origin = "local") {
+export async function applyOrderStateChangeEvent(event, origin = "local") {
     try {
         if (!ORDER_STATE_EVENT_TYPES.has(event.event_type))
             return;
-        sync_logger_1.syncLogger.debug("OrderState", "Order state changed", {
+        syncLogger.debug("OrderState", "Order state changed", {
             origin,
             event_type: event.event_type,
             entity_id: event.entity_id,
         });
         // Persist the event into the durable journal and patch the offline read
         // model so every terminal keeps the same order states after a restart.
-        await order_snapshots_service_1.orderSnapshotsService.persistOrderEvent(event, origin);
+        await orderSnapshotsService.persistOrderEvent(event, origin);
         invalidator?.();
     }
     catch (error) {
-        sync_logger_1.syncLogger.error("OrderState", "Failed to apply order state change", {
+        syncLogger.error("OrderState", "Failed to apply order state change", {
             error: String(error),
             event_type: event.event_type,
         });
     }
 }
-async function applyPendingOrderEvent(event, origin = "local") {
+export async function applyPendingOrderEvent(event, origin = "local") {
     try {
         if (event.event_type === PENDING_EVENT_TYPE) {
             const order = event.payload;
             if (!order?.order_number)
                 return;
-            pending_orders_1.usePendingOrdersStore.getState().addOrder(order);
-            const db = await (0, connection_1.openSyncDatabase)();
-            await (0, operations_1.insertEvent)(db, { event, origin });
+            usePendingOrdersStore.getState().addOrder(order);
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
             return;
         }
         if (event.event_type === "order.created") {
@@ -129,16 +123,16 @@ async function applyPendingOrderEvent(event, origin = "local") {
             const localOrderNumber = payload?.local_order_number;
             if (typeof localOrderNumber !== "string")
                 return;
-            pending_orders_1.usePendingOrdersStore.getState().removeByOrderNumber(localOrderNumber);
+            usePendingOrdersStore.getState().removeByOrderNumber(localOrderNumber);
             // Persist the cloud acknowledgment into the durable journal + read model.
-            await order_snapshots_service_1.orderSnapshotsService.persistOrderEvent(event, "cloud");
-            const db = await (0, connection_1.openSyncDatabase)();
+            await orderSnapshotsService.persistOrderEvent(event, "cloud");
+            const db = await openSyncDatabase();
             // Mark every persisted optimistic event for this local order number as
             // synced so it does not rehydrate as pending after a restart. Check both
             // origins: the creating terminal persisted "local", LAN clients "lan".
             const ids = [];
             for (const origin of ["local", "lan"]) {
-                const unsynced = await (0, operations_1.getUnsyncedEvents)(db, origin, Number.MAX_SAFE_INTEGER);
+                const unsynced = await getUnsyncedEvents(db, origin, Number.MAX_SAFE_INTEGER);
                 for (const e of unsynced) {
                     if (e.event_type !== PENDING_EVENT_TYPE)
                         continue;
@@ -149,13 +143,13 @@ async function applyPendingOrderEvent(event, origin = "local") {
                 }
             }
             if (ids.length > 0) {
-                await (0, operations_1.markEventsSynced)(db, ids);
+                await markEventsSynced(db, ids);
             }
             invalidator?.();
         }
     }
     catch (error) {
-        sync_logger_1.syncLogger.error("PendingOrders", "Failed to apply event", {
+        syncLogger.error("PendingOrders", "Failed to apply event", {
             error: String(error),
             event_type: event.event_type,
         });

package/dist/sync/transport-local-node.js

@@ -1,67 +1,63 @@
-"use strict";
 /**
  * Local Node Transport.
  *
  * Routes commands to the elected Local Node over the LAN and receives events
  * broadcast by the Local Node.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.localNodeTransport = exports.LocalNodeTransport = void 0;
-const local_node_1 = require("../adapters/local-node");
-const sync_logger_1 = require("../utils/sync-logger");
-class LocalNodeTransport {
+import { useLocalNodeStore, localNodeService } from "../adapters/local-node";
+import { syncLogger } from "../utils/sync-logger";
+export class LocalNodeTransport {
     constructor() {
         this.name = "local_node";
     }
     isAvailable() {
-        const store = local_node_1.useLocalNodeStore.getState();
+        const store = useLocalNodeStore.getState();
         if (!store.isLocalNodeEnabled)
             return false;
         // If this device is the Local Node, it is always available.
-        if (local_node_1.localNodeService.isLocalNode())
+        if (localNodeService.isLocalNode())
             return true;
         // Otherwise, we must be connected to the elected node.
-        return local_node_1.localNodeService.isConnectedToNode();
+        return localNodeService.isConnectedToNode();
     }
     subscribe() {
         // Events are received through the LocalNodeService event pipeline.
         return () => undefined;
     }
     async execute(command) {
-        sync_logger_1.syncLogger.transport(this, "executing", {
+        syncLogger.transport(this, "executing", {
             command_type: command.command_type,
             command_id: command.command_id,
         });
-        if (local_node_1.localNodeService.isLocalNode()) {
+        if (localNodeService.isLocalNode()) {
             // This device is the Local Node: execute locally.
-            sync_logger_1.syncLogger.info("LocalNodeTransport", "Executing on local node (self)", {
+            syncLogger.info("LocalNodeTransport", "Executing on local node (self)", {
                 command_type: command.command_type,
                 command_id: command.command_id,
             });
-            const event = await local_node_1.localNodeService.handleNodeCommand(command);
-            sync_logger_1.syncLogger.transport(this, "completed", {
+            const event = await localNodeService.handleNodeCommand(command);
+            syncLogger.transport(this, "completed", {
                 command_type: command.command_type,
                 event_type: event?.event_type,
             });
             return event ? [event] : [];
         }
         // Client: send command to the Local Node.
-        const client = local_node_1.localNodeService.getClient();
+        const client = localNodeService.getClient();
         if (!client) {
             throw new Error("LocalNodeTransport: no client connected to Local Node");
         }
-        sync_logger_1.syncLogger.info("LocalNodeTransport", "Sending command to Local Node", {
+        syncLogger.info("LocalNodeTransport", "Sending command to Local Node", {
             command_type: command.command_type,
             command_id: command.command_id,
-            node_device_id: local_node_1.localNodeService.getElectedNode()?.deviceId,
+            node_device_id: localNodeService.getElectedNode()?.deviceId,
         });
         const events = await client.execute(command);
-        sync_logger_1.syncLogger.transport(this, "completed", {
+        syncLogger.transport(this, "completed", {
             command_type: command.command_type,
             event_count: events.length,
         });
         return events;
     }
 }
-exports.LocalNodeTransport = LocalNodeTransport;
-exports.localNodeTransport = new LocalNodeTransport();
+export const localNodeTransport = new LocalNodeTransport();

package/dist/sync/transport-rest.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * REST transport implementation.
  *
@@ -6,12 +5,10 @@
  * resulting domain events. This transport is used when the cloud API is
  * reachable.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.restTransport = exports.RestTransport = void 0;
-const services_1 = require("../adapters/services");
-const sync_logger_1 = require("../utils/sync-logger");
-const uuid_1 = require("../utils/uuid");
-class RestTransport {
+import { posService, sellerService, kioskService } from "../adapters/services";
+import { syncLogger } from "../utils/sync-logger";
+import { generateEventId } from "../utils/uuid";
+export class RestTransport {
     constructor() {
         this.name = "rest";
     }
@@ -25,20 +22,20 @@ class RestTransport {
         return () => undefined;
     }
     async execute(command) {
-        sync_logger_1.syncLogger.transport(this, "executing", {
+        syncLogger.transport(this, "executing", {
             command_type: command.command_type,
             command_id: command.command_id,
         });
         try {
             const event = await this.dispatchCommand(command);
-            sync_logger_1.syncLogger.transport(this, "completed", {
+            syncLogger.transport(this, "completed", {
                 command_type: command.command_type,
                 event_type: event?.event_type,
             });
             return event ? [event] : [];
         }
         catch (error) {
-            sync_logger_1.syncLogger.transport(this, "error", {
+            syncLogger.transport(this, "error", {
                 command_type: command.command_type,
                 command_id: command.command_id,
                 error: error instanceof Error ? error.message : String(error),
@@ -56,39 +53,39 @@ class RestTransport {
                     command_id: command.command_id,
                     local_order_number: payload.order_number,
                 };
-                const response = await services_1.posService.createPOSOrder(business_id, posPayload);
+                const response = await posService.createPOSOrder(business_id, posPayload);
                 return this.wrapResponse("order.created", response.data, entity_id, timestamp, command);
             }
             case "order:accept": {
-                const response = await services_1.sellerService.acceptOrder(entity_id);
+                const response = await sellerService.acceptOrder(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "order:reject": {
-                const response = await services_1.sellerService.rejectOrder(entity_id);
+                const response = await sellerService.rejectOrder(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "order:start_preparing": {
-                const response = await services_1.sellerService.startPreparingOrder(entity_id);
+                const response = await sellerService.startPreparingOrder(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "order:mark_ready": {
-                const response = await services_1.sellerService.markOrderReady(entity_id);
+                const response = await sellerService.markOrderReady(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "order:complete_pickup": {
-                const response = await services_1.sellerService.completeOrderPickup(entity_id);
+                const response = await sellerService.completeOrderPickup(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "order:cancel": {
-                const response = await services_1.sellerService.cancelOrder(entity_id);
+                const response = await sellerService.cancelOrder(entity_id);
                 return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
             }
             case "delivery:assign": {
-                const response = await services_1.kioskService.assignKioskOrderToRider(entity_id, payload.rider_id);
+                const response = await kioskService.assignKioskOrderToRider(entity_id, payload.rider_id);
                 return this.wrapResponse("delivery.assigned", response, entity_id, timestamp, command);
             }
             case "delivery:confirm_handover": {
-                const response = await services_1.sellerService.confirmHandover(entity_id);
+                const response = await sellerService.confirmHandover(entity_id);
                 return this.wrapResponse("delivery.status_changed", response, entity_id, timestamp, command);
             }
             default:
@@ -97,7 +94,7 @@ class RestTransport {
     }
     wrapResponse(eventType, data, entityId, timestamp, command) {
         return {
-            event_id: (0, uuid_1.generateEventId)(),
+            event_id: generateEventId(),
             event_type: eventType,
             event_version: "1.0",
             entity_id: entityId ?? command.entity_id ?? data.id ?? "unknown",
@@ -108,5 +105,4 @@ class RestTransport {
         };
     }
 }
-exports.RestTransport = RestTransport;
-exports.restTransport = new RestTransport();
+export const restTransport = new RestTransport();

package/dist/sync/types.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Core types for the offline-first, event-driven Sync Engine.
  *
@@ -10,4 +9,4 @@
  *
  * All timestamps are ISO strings. Monetary amounts remain in minor units.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Sync reconciliation bridge.
  *
@@ -8,18 +7,16 @@
  *   - Marks reconciled optimistic events as synced to cloud.
  *   - Invalidates TanStack Query caches for affected entities.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSyncReconciliation = useSyncReconciliation;
-const react_1 = require("react");
-const react_query_1 = require("@tanstack/react-query");
-const engine_1 = require("./engine");
-const pending_orders_service_1 = require("./pending-orders.service");
-const local_node_1 = require("../adapters/local-node");
-const connection_1 = require("../db/connection");
-const operations_1 = require("../db/operations");
-const sync_logger_1 = require("../utils/sync-logger");
-const query_keys_1 = require("../adapters/query-keys");
-const events_1 = require("../reference/events");
+import { useEffect } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { syncEngine } from "./engine";
+import { applyPendingOrderEvent, applyOrderStateChangeEvent, registerPendingOrdersInvalidator, } from "./pending-orders.service";
+import { localNodeService } from "../adapters/local-node";
+import { getSyncDatabase } from "../db/connection";
+import { markEventsSynced } from "../db/operations";
+import { syncLogger } from "../utils/sync-logger";
+import { POS_KEYS, SELLER_KEYS, MENU_KEYS, REFERENCE_KEYS } from "../adapters/query-keys";
+import { applyReferenceChangeEvent, registerReferenceInvalidator, registerReferenceEventEngine, REFERENCE_CHANGED_EVENT_TYPE, } from "../reference/events";
 function isLocalOrderEvent(event) {
     const payload = event.payload;
     if (!payload)
@@ -27,73 +24,73 @@ function isLocalOrderEvent(event) {
     const localOrderNumber = payload.local_order_number;
     return typeof localOrderNumber === "string" && localOrderNumber.startsWith("TFL-");
 }
-function useSyncReconciliation() {
-    const queryClient = (0, react_query_1.useQueryClient)();
-    (0, react_1.useEffect)(() => {
+export function useSyncReconciliation() {
+    const queryClient = useQueryClient();
+    useEffect(() => {
         // Reference changes re-sync offline data and refresh caches on this device
         // and (via the LAN relay) on every connected terminal.
-        const unregisterReferenceInvalidator = (0, events_1.registerReferenceInvalidator)(() => {
-            queryClient.invalidateQueries({ queryKey: query_keys_1.MENU_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: query_keys_1.REFERENCE_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: query_keys_1.POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: query_keys_1.SELLER_KEYS.all });
+        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 });
         });
         // Pending-order reconciliation invalidates POS + seller order lists so the
         // server-confirmed order replaces the optimistic one. Invalidate from the
         // broadest key: POS_KEYS.orders() without a businessId would produce
         // ['pos','orders',undefined] which does not prefix-match business-scoped
         // keys.
-        const unregisterInvalidator = (0, pending_orders_service_1.registerPendingOrdersInvalidator)(() => {
-            queryClient.invalidateQueries({ queryKey: query_keys_1.POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: query_keys_1.SELLER_KEYS.all });
+        const unregisterInvalidator = registerPendingOrdersInvalidator(() => {
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
         });
         // 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.
-        (0, events_1.registerReferenceEventEngine)(engine_1.syncEngine);
-        const unsubscribe = engine_1.syncEngine.subscribe(async (event) => {
-            sync_logger_1.syncLogger.event(event, "received");
+        registerReferenceEventEngine(syncEngine);
+        const unsubscribe = syncEngine.subscribe(async (event) => {
+            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
             // orders and refresh caches.
-            if (local_node_1.localNodeService.isLocalNode()) {
-                local_node_1.localNodeService.broadcastToClients(event);
+            if (localNodeService.isLocalNode()) {
+                localNodeService.broadcastToClients(event);
             }
             // Reference data changed on this device but we are a LAN client (not the
             // node): forward the event to the node so it rebroadcasts it to every
             // other terminal (the node also applies it locally via its onRelayEvent
             // hook). The node does not echo it back to this device.
-            if (event.event_type === events_1.REFERENCE_CHANGED_EVENT_TYPE &&
-                !local_node_1.localNodeService.isLocalNode()) {
-                local_node_1.localNodeService.getClient()?.publishEvent?.(event);
+            if (event.event_type === REFERENCE_CHANGED_EVENT_TYPE &&
+                !localNodeService.isLocalNode()) {
+                localNodeService.getClient()?.publishEvent?.(event);
             }
             // Reference data changed (locally or echoed from the cloud): re-sync the
             // affected keys and refresh caches on this device.
-            await (0, events_1.applyReferenceChangeEvent)(event, "local");
+            await applyReferenceChangeEvent(event, "local");
             // Order/delivery state changed: refresh order caches so this terminal
             // shows the same order states as the device that made the change.
-            await (0, pending_orders_service_1.applyOrderStateChangeEvent)(event, "local");
+            await applyOrderStateChangeEvent(event, "local");
             // Route both queued (optimistic) and reconciled (created) order events
             // into the pending-orders store.
             if (event.event_type === "order.create_queued" ||
                 event.event_type === "order.created") {
-                await (0, pending_orders_service_1.applyPendingOrderEvent)(event, "local");
+                await applyPendingOrderEvent(event, "local");
             }
             if (event.event_type === "order.created" && isLocalOrderEvent(event)) {
                 try {
-                    const db = (0, connection_1.getSyncDatabase)();
-                    await (0, operations_1.markEventsSynced)(db, [event.event_id]);
+                    const db = getSyncDatabase();
+                    await markEventsSynced(db, [event.event_id]);
                 }
                 catch (error) {
-                    sync_logger_1.syncLogger.error("Reconciliation", "Failed to mark event synced", {
+                    syncLogger.error("Reconciliation", "Failed to mark event synced", {
                         error: String(error),
                     });
                 }
                 const payload = event.payload;
                 const businessId = payload.business_id;
                 if (businessId) {
-                    queryClient.invalidateQueries({ queryKey: query_keys_1.POS_KEYS.orders(businessId) });
-                    queryClient.invalidateQueries({ queryKey: query_keys_1.SELLER_KEYS.all });
+                    queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
+                    queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
                 }
             }
         });

package/dist/types/api/auth.api.js

@@ -1,3 +1,2 @@
-"use strict";
 // ─── Auth Requests ───
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/api/business.api.js

@@ -1,3 +1,2 @@
-"use strict";
 // ─── Business ───
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/api/conversation.api.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/api/error.api.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/api/fleet.api.js

@@ -1,3 +1,2 @@
-"use strict";
 // ─── Fleet Rider ───
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};