@teincfood/core 0.1.1 → 0.1.3

package/dist/sync/engine.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Sync Engine orchestrator.
  *
@@ -12,15 +11,13 @@
  *   - Local Node transport
  *   - cloud reconciliation
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncEngine = exports.SyncEngine = void 0;
-const transport_rest_1 = require("./transport-rest");
-const transport_local_node_1 = require("./transport-local-node");
-const command_queue_service_1 = require("./command-queue.service");
-const connectivity_1 = require("../adapters/connectivity");
-const http_1 = require("../adapters/http");
-const sync_logger_1 = require("../utils/sync-logger");
-const constants_1 = require("../utils/constants");
+import { restTransport } from "./transport-rest";
+import { localNodeTransport } from "./transport-local-node";
+import { commandQueueService } from "./command-queue.service";
+import { getConnectivityState, setConnectivityState } from "../adapters/connectivity";
+import { ApiError } from "../adapters/http";
+import { syncLogger } from "../utils/sync-logger";
+import { CLOUD_COMMAND_TIMEOUT_MS } from "../utils/constants";
 function withTimeout(promise, ms) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -35,7 +32,7 @@ function withTimeout(promise, ms) {
         });
     });
 }
-class SyncEngine {
+export class SyncEngine {
     constructor(options) {
         this.eventSubscribers = [];
         this.transports = options.transports;
@@ -53,37 +50,37 @@ class SyncEngine {
      * quickly instead of blocking the terminal for the full HTTP timeout.
      */
     async execute(command) {
-        sync_logger_1.syncLogger.command(command, "issued");
+        syncLogger.command(command, "issued");
         let strategy = this.resolveStrategy(command);
-        const { isCloudReachable, isOnline } = (0, connectivity_1.getConnectivityState)();
-        sync_logger_1.syncLogger.info("SyncEngine", "Command strategy resolved", {
+        const { isCloudReachable, isOnline } = getConnectivityState();
+        syncLogger.info("SyncEngine", "Command strategy resolved", {
             command_id: command.command_id,
             command_type: command.command_type,
             strategy,
             isCloudReachable,
             isOnline,
-            cloud_available: transport_rest_1.restTransport.isAvailable(),
-            lan_available: transport_local_node_1.localNodeTransport.isAvailable(),
+            cloud_available: restTransport.isAvailable(),
+            lan_available: localNodeTransport.isAvailable(),
         });
         if (strategy === "queue") {
-            const event = await command_queue_service_1.commandQueueService.enqueue(command);
+            const event = await commandQueueService.enqueue(command);
             this.broadcast(event);
             return [event];
         }
         if (strategy === "cloud") {
             try {
-                const events = await withTimeout(transport_rest_1.restTransport.execute(command), constants_1.CLOUD_COMMAND_TIMEOUT_MS);
+                const events = await withTimeout(restTransport.execute(command), CLOUD_COMMAND_TIMEOUT_MS);
                 for (const event of events) {
                     this.broadcast(event);
                 }
-                sync_logger_1.syncLogger.command(command, "completed", {
+                syncLogger.command(command, "completed", {
                     event_count: events.length,
                 });
                 // Cloud just worked: it is reachable again. Mark it so future commands
                 // go cloud-first, and replay anything queued during the outage.
-                (0, connectivity_1.setConnectivityState)({ isCloudReachable: "reachable" });
+                setConnectivityState({ isCloudReachable: "reachable" });
                 this.replayQueuedCommands().catch((error) => {
-                    sync_logger_1.syncLogger.error("SyncEngine", "Replay after cloud success failed", {
+                    syncLogger.error("SyncEngine", "Replay after cloud success failed", {
                         error: String(error),
                     });
                 });
@@ -94,8 +91,8 @@ class SyncEngine {
                 // decision (e.g. PAYMENT_REQUIRED, FORBIDDEN). Surface it to the
                 // caller instead of masking it as a connectivity problem and silently
                 // queueing a command that can never succeed.
-                if (error instanceof http_1.ApiError && error.status >= 400 && error.status < 500) {
-                    sync_logger_1.syncLogger.warn("SyncEngine", "Cloud command rejected by server", {
+                if (error instanceof ApiError && error.status >= 400 && error.status < 500) {
+                    syncLogger.warn("SyncEngine", "Cloud command rejected by server", {
                         command_type: command.command_type,
                         command_id: command.command_id,
                         status: error.status,
@@ -105,18 +102,18 @@ class SyncEngine {
                 }
                 // Cloud is slow or unreachable: mark it and fall back to the Local
                 // Node or the outbox so the terminal stays responsive.
-                sync_logger_1.syncLogger.warn("SyncEngine", "Cloud command timed out, falling back", {
+                syncLogger.warn("SyncEngine", "Cloud command timed out, falling back", {
                     command_type: command.command_type,
                     error: String(error),
                 });
-                (0, connectivity_1.setConnectivityState)({ isCloudReachable: "unreachable" });
+                setConnectivityState({ isCloudReachable: "unreachable" });
                 strategy = this.resolveStrategy(command);
                 if (strategy === "queue") {
-                    const event = await command_queue_service_1.commandQueueService.enqueue(command);
+                    const event = await commandQueueService.enqueue(command);
                     this.broadcast(event);
                     return [event];
                 }
-                sync_logger_1.syncLogger.info("SyncEngine", "Cloud timed out, using LAN fallback", {
+                syncLogger.info("SyncEngine", "Cloud timed out, using LAN fallback", {
                     command_id: command.command_id,
                     command_type: command.command_type,
                     strategy,
@@ -124,7 +121,7 @@ class SyncEngine {
             }
         }
         const transport = this.selectTransport(command, strategy);
-        sync_logger_1.syncLogger.info("SyncEngine", "Executing via transport", {
+        syncLogger.info("SyncEngine", "Executing via transport", {
             command_id: command.command_id,
             command_type: command.command_type,
             strategy,
@@ -134,7 +131,7 @@ class SyncEngine {
         for (const event of events) {
             this.broadcast(event);
         }
-        sync_logger_1.syncLogger.command(command, "completed", {
+        syncLogger.command(command, "completed", {
             event_count: events.length,
             transport: transport.name,
         });
@@ -144,7 +141,7 @@ class SyncEngine {
      * Trigger replay of queued commands when connectivity returns.
      */
     async replayQueuedCommands() {
-        await command_queue_service_1.commandQueueService.replay();
+        await commandQueueService.replay();
     }
     subscribe(handler) {
         this.eventSubscribers.push(handler);
@@ -165,17 +162,17 @@ class SyncEngine {
         this.broadcast(event);
     }
     resolveStrategy(_command) {
-        const { isCloudReachable, isOnline } = (0, connectivity_1.getConnectivityState)();
+        const { isCloudReachable, isOnline } = getConnectivityState();
         // Cloud-first when we believe it is reachable OR we have not yet verified
         // it (unknown). Only a confirmed "unreachable" status falls back to the
         // Local Node / outbox. Commands issued on a healthy connection must never
         // get stuck in the local outbox.
         if ((isCloudReachable === "reachable" || isCloudReachable === "unknown") &&
-            transport_rest_1.restTransport.isAvailable()) {
+            restTransport.isAvailable()) {
             return "cloud";
         }
         // Local Node fallback when enabled and connected.
-        if (transport_local_node_1.localNodeTransport.isAvailable()) {
+        if (localNodeTransport.isAvailable()) {
             return "local_node";
         }
         // No network at all: queue immediately.
@@ -192,11 +189,11 @@ class SyncEngine {
         return "cloud";
     }
     selectTransport(_command, strategy) {
-        if (strategy === "local_node" && transport_local_node_1.localNodeTransport.isAvailable()) {
-            return transport_local_node_1.localNodeTransport;
+        if (strategy === "local_node" && localNodeTransport.isAvailable()) {
+            return localNodeTransport;
         }
-        if (strategy === "cloud" && transport_rest_1.restTransport.isAvailable()) {
-            return transport_rest_1.restTransport;
+        if (strategy === "cloud" && restTransport.isAvailable()) {
+            return restTransport;
         }
         const transport = this.transports.find((t) => t.isAvailable()) ?? this.transports[0];
         if (!transport) {
@@ -205,12 +202,11 @@ class SyncEngine {
         return transport;
     }
     broadcast(event) {
-        sync_logger_1.syncLogger.event(event, "broadcast");
+        syncLogger.event(event, "broadcast");
         this.eventSubscribers.forEach((handler) => handler(event));
     }
 }
-exports.SyncEngine = SyncEngine;
-exports.syncEngine = new SyncEngine({
-    transports: [transport_rest_1.restTransport, transport_local_node_1.localNodeTransport],
+export const syncEngine = new SyncEngine({
+    transports: [restTransport, localNodeTransport],
 });
-command_queue_service_1.commandQueueService.setSyncEngine(exports.syncEngine);
+commandQueueService.setSyncEngine(syncEngine);

package/dist/sync/order-number.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Local order number allocation for offline/LAN operation.
  *
@@ -7,11 +6,7 @@
  * `TFL-YYYYMMDD-NNNN`. These are reconciled with permanent cloud order numbers
  * once connectivity returns.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateLocalOrderNumber = generateLocalOrderNumber;
-exports.generateLocalCalloutNumber = generateLocalCalloutNumber;
-exports.isLocalOrderNumber = isLocalOrderNumber;
-const kv_1 = require("../adapters/kv");
+import { getItemSync as getItem, setItemSync as setItem } from "../adapters/kv";
 const LOCAL_ORDER_SEQ_KEY = "local_order_sequence";
 const LOCAL_CALLOUT_SEQ_KEY = "local_callout_sequence";
 function formatDatePart(date) {
@@ -21,7 +16,7 @@ function formatDatePart(date) {
     return `${year}${month}${day}`;
 }
 function getNextSequence(datePart, key) {
-    const stored = (0, kv_1.getItemSync)(key);
+    const stored = getItem(key);
     const map = stored ?? {};
     const next = (map[datePart] ?? 0) + 1;
     map[datePart] = next;
@@ -32,13 +27,13 @@ function getNextSequence(datePart, key) {
             delete map[mapKey];
         }
     }
-    (0, kv_1.setItemSync)(key, map);
+    setItem(key, map);
     return next;
 }
 /**
  * Generate a local order number for offline-created orders.
  */
-function generateLocalOrderNumber(date = new Date()) {
+export function generateLocalOrderNumber(date = new Date()) {
     const datePart = formatDatePart(date);
     const seq = getNextSequence(datePart, LOCAL_ORDER_SEQ_KEY);
     return `TFL-${datePart}-${String(seq).padStart(4, "0")}`;
@@ -46,13 +41,13 @@ function generateLocalOrderNumber(date = new Date()) {
 /**
  * Generate a local callout number for offline-created orders.
  */
-function generateLocalCalloutNumber(date = new Date()) {
+export function generateLocalCalloutNumber(date = new Date()) {
     const datePart = formatDatePart(date);
     return getNextSequence(datePart, LOCAL_CALLOUT_SEQ_KEY);
 }
 /**
  * Check whether an order number was locally allocated.
  */
-function isLocalOrderNumber(orderNumber) {
+export function isLocalOrderNumber(orderNumber) {
     return orderNumber.startsWith("TFL-");
 }

package/dist/sync/order-number.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sync/order-number.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber } from "./order-number";
+import { removeItemSync } from "../adapters/kv";
+// Use in-memory KV for tests (default driver is memory)
+describe("order-number", () => {
+    beforeEach(() => {
+        removeItemSync("local_order_sequence");
+        removeItemSync("local_callout_sequence");
+    });
+    it("generates TFL order numbers with date and sequence", () => {
+        const d = new Date("2026-08-24T10:00:00.000Z");
+        const a = generateLocalOrderNumber(d);
+        const b = generateLocalOrderNumber(d);
+        expect(a).toBe("TFL-20260824-0001");
+        expect(b).toBe("TFL-20260824-0002");
+        expect(isLocalOrderNumber(a)).toBe(true);
+        expect(isLocalOrderNumber("KF-260701-0042")).toBe(false);
+    });
+    it("generates incremental callout numbers per day", () => {
+        const d = new Date("2026-08-24T10:00:00.000Z");
+        expect(generateLocalCalloutNumber(d)).toBe(1);
+        expect(generateLocalCalloutNumber(d)).toBe(2);
+    });
+    it("isolates sequences per day", () => {
+        const d1 = new Date("2026-08-24T10:00:00.000Z");
+        const d2 = new Date("2026-08-25T10:00:00.000Z");
+        expect(generateLocalOrderNumber(d1)).toBe("TFL-20260824-0001");
+        expect(generateLocalOrderNumber(d2)).toBe("TFL-20260825-0001");
+    });
+});

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();