@teincfood/core 0.1.1 → 0.1.2

package/dist/repositories/order.repository.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Order Repository.
  *
@@ -8,10 +7,8 @@
  * In Phase 1, commands execute immediately through the REST transport.
  * Future phases will queue commands when offline.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderRepository = void 0;
-const engine_1 = require("../sync/engine");
-const command_builder_1 = require("../sync/command-builder");
+import { syncEngine } from "../sync/engine";
+import { buildCommand } from "../sync/command-builder";
 async function executeCommand(command) {
     console.debug("[OrderRepository] Dispatching command", JSON.stringify({
         command_id: command.command_id,
@@ -21,7 +18,7 @@ async function executeCommand(command) {
         payload_keys: Object.keys(command.payload ?? {}),
         timestamp: new Date().toISOString(),
     }));
-    const events = await engine_1.syncEngine.execute(command);
+    const events = await syncEngine.execute(command);
     const event = events[0];
     console.debug("[OrderRepository] Command result", JSON.stringify({
         command_id: command.command_id,
@@ -37,9 +34,9 @@ async function executeCommand(command) {
     }
     return event.payload;
 }
-exports.orderRepository = {
+export const orderRepository = {
     async createOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:create",
             businessId: input.businessId,
             entityId: input.entityId,
@@ -48,7 +45,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async acceptOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:accept",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -57,7 +54,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async rejectOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:reject",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -66,7 +63,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async startPreparingOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:start_preparing",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -75,7 +72,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async markOrderReady(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:mark_ready",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -84,7 +81,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async completePickup(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:complete_pickup",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -93,7 +90,7 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async cancelOrder(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "order:cancel",
             businessId: input.businessId,
             entityId: input.orderId,
@@ -102,13 +99,13 @@ exports.orderRepository = {
         return executeCommand(command);
     },
     async confirmHandover(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "delivery:confirm_handover",
             businessId: input.businessId,
             entityId: input.deliveryId,
             payload: {},
         });
-        const events = await engine_1.syncEngine.execute(command);
+        const events = await syncEngine.execute(command);
         const event = events[0];
         if (!event) {
             throw new Error("OrderRepository: confirmHandover returned no events");
@@ -116,13 +113,13 @@ exports.orderRepository = {
         return event.payload;
     },
     async assignRider(input) {
-        const command = (0, command_builder_1.buildCommand)({
+        const command = buildCommand({
             commandType: "delivery:assign",
             businessId: input.businessId,
             entityId: input.orderId,
             payload: { rider_id: input.riderId },
         });
-        const events = await engine_1.syncEngine.execute(command);
+        const events = await syncEngine.execute(command);
         const event = events[0];
         if (!event) {
             throw new Error("OrderRepository: assignRider returned no events");

package/dist/repositories/pos.repository.js

@@ -1,20 +1,17 @@
-"use strict";
 /**
  * POS Repository.
  *
  * Domain-specific operations for the POS terminal. Builds on OrderRepository
  * for commands and keeps read/query operations behind a repository interface.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.posRepository = void 0;
-const services_1 = require("../adapters/services");
-const order_repository_1 = require("./order.repository");
-exports.posRepository = {
+import { posService } from "../adapters/services";
+import { orderRepository } from "./order.repository";
+export const posRepository = {
     async createOrder(businessId, data, entityId) {
-        return order_repository_1.orderRepository.createOrder({ businessId, data, entityId });
+        return orderRepository.createOrder({ businessId, data, entityId });
     },
     async fetchPreview(input) {
-        const res = await services_1.posService.fetchPOSOrderPreview(input.businessId, {
+        const res = await posService.fetchPOSOrderPreview(input.businessId, {
             items: input.items,
             order_type: input.orderType,
             customer_name: input.customerName,
@@ -22,7 +19,7 @@ exports.posRepository = {
         return res;
     },
     async fetchOrders(businessId, params) {
-        const res = await services_1.posService.fetchBusinessOrders(businessId, params);
+        const res = await posService.fetchBusinessOrders(businessId, params);
         return res;
     },
 };

package/dist/sync/command-builder.js

@@ -1,23 +1,18 @@
-"use strict";
 /**
  * Command builder helpers.
  *
  * Centralizes creation of Command objects with consistent metadata
  * (command_id, user_id, device_id, timestamps).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAppInstanceId = void 0;
-exports.buildCommand = buildCommand;
-const auth_1 = require("../adapters/auth");
-const devices_1 = require("../adapters/devices");
-Object.defineProperty(exports, "getAppInstanceId", { enumerable: true, get: function () { return devices_1.getAppInstanceId; } });
-const uuid_1 = require("../utils/uuid");
-function buildCommand(options) {
-    const user = auth_1.useAuthStore.getState().user;
+import { useAuthStore } from "../adapters/auth";
+import { getAppInstanceId } from "../adapters/devices";
+import { generateCommandId } from "../utils/uuid";
+export function buildCommand(options) {
+    const user = useAuthStore.getState().user;
     const userId = user?.id ?? "anonymous";
-    const deviceId = (0, devices_1.getAppInstanceId)();
+    const deviceId = getAppInstanceId();
     return {
-        command_id: (0, uuid_1.generateCommandId)(),
+        command_id: generateCommandId(),
         command_type: options.commandType,
         command_version: options.commandVersion ?? "1.0",
         business_id: options.businessId,
@@ -28,3 +23,4 @@ function buildCommand(options) {
         payload: options.payload,
     };
 }
+export { getAppInstanceId };

package/dist/sync/command-queue.service.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Command Queue Service.
  *
@@ -9,18 +8,16 @@
  *   - Replay queued commands when a transport becomes available.
  *   - Provide optimistic domain events so the UI can render pending orders.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandQueueService = void 0;
-const connection_1 = require("../db/connection");
-const operations_1 = require("../db/operations");
-const sync_logger_1 = require("../utils/sync-logger");
-const uuid_1 = require("../utils/uuid");
-const order_number_1 = require("./order-number");
+import { getSyncDatabase, openSyncDatabase } from "../db/connection";
+import { insertCommand, getPendingCommands, markCommandInFlight, updateCommandStatus, deleteCommand, insertEvent, } from "../db/operations";
+import { syncLogger } from "../utils/sync-logger";
+import { generateEventId } from "../utils/uuid";
+import { generateLocalOrderNumber, generateLocalCalloutNumber, } from "./order-number";
 const MAX_RETRIES = 5;
 function buildOptimisticEvent(command) {
     const payload = command.payload;
     return {
-        event_id: (0, uuid_1.generateEventId)(),
+        event_id: generateEventId(),
         event_type: `${command.command_type.replace(":", ".")}_queued`,
         event_version: "1.0",
         entity_id: command.entity_id ?? command.command_id,
@@ -40,11 +37,11 @@ function buildOptimisticOrder(command, payload) {
     const items = payload.items ?? [];
     const totalMinor = payload.total_minor ?? 0;
     const now = new Date().toISOString();
-    const orderNumber = payload.order_number ?? (0, order_number_1.generateLocalOrderNumber)();
+    const orderNumber = payload.order_number ?? generateLocalOrderNumber();
     return {
         id: command.entity_id ?? command.command_id,
         order_number: orderNumber,
-        callout_number: (0, order_number_1.generateLocalCalloutNumber)(),
+        callout_number: generateLocalCalloutNumber(),
         order_type: payload.order_type ?? "takeout",
         is_pos: true,
         customer_name: payload.customer_name ?? null,
@@ -104,7 +101,7 @@ function injectLocalOrderNumber(command) {
         ...command,
         payload: {
             ...payload,
-            order_number: (0, order_number_1.generateLocalOrderNumber)(),
+            order_number: generateLocalOrderNumber(),
         },
     };
 }
@@ -121,19 +118,19 @@ class CommandQueueService {
      * Returns an optimistic domain event so the caller can update the UI.
      */
     async enqueue(command) {
-        const db = (0, connection_1.getSyncDatabase)();
+        const db = getSyncDatabase();
         const preparedCommand = injectLocalOrderNumber(command);
-        await (0, operations_1.insertCommand)(db, { command: preparedCommand, status: "pending" });
-        sync_logger_1.syncLogger.command(preparedCommand, "queued");
-        const pending = await (0, operations_1.getPendingCommands)(db, Number.MAX_SAFE_INTEGER);
-        sync_logger_1.syncLogger.info("CommandQueueService", "Command queued offline", {
+        await insertCommand(db, { command: preparedCommand, status: "pending" });
+        syncLogger.command(preparedCommand, "queued");
+        const pending = await getPendingCommands(db, Number.MAX_SAFE_INTEGER);
+        syncLogger.info("CommandQueueService", "Command queued offline", {
             command_id: preparedCommand.command_id,
             command_type: preparedCommand.command_type,
             order_number: preparedCommand.payload.order_number ?? null,
             outbox_size: pending.length,
         });
         const event = buildOptimisticEvent(preparedCommand);
-        sync_logger_1.syncLogger.info("CommandQueueService", "Optimistic event built", {
+        syncLogger.info("CommandQueueService", "Optimistic event built", {
             event_type: event.event_type,
             entity_id: event.entity_id,
             order_number: event.payload.order_number ?? null,
@@ -143,10 +140,10 @@ class CommandQueueService {
         // rehydrated (and shown) while still offline.
         if (preparedCommand.command_type === "order:create") {
             try {
-                await (0, operations_1.insertEvent)(db, { event, origin: "local" });
+                await insertEvent(db, { event, origin: "local" });
             }
             catch (error) {
-                sync_logger_1.syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
+                syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
                     error: String(error),
                 });
             }
@@ -157,7 +154,7 @@ class CommandQueueService {
      * Try to execute a single pending command through the current transport.
      */
     async processCommand(command) {
-        const db = (0, connection_1.getSyncDatabase)();
+        const db = getSyncDatabase();
         const parsedCommand = {
             command_id: command.command_id,
             command_type: command.command_type,
@@ -170,20 +167,20 @@ class CommandQueueService {
             payload: command.payload,
         };
         if (command.retry_count >= MAX_RETRIES) {
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "failed", "Max retry count exceeded");
+            await updateCommandStatus(db, command.command_id, "failed", "Max retry count exceeded");
             return;
         }
         if (!this.syncEngine) {
             throw new Error("CommandQueueService: SyncEngine not initialized");
         }
-        await (0, operations_1.markCommandInFlight)(db, command.command_id);
+        await markCommandInFlight(db, command.command_id);
         try {
             const events = await this.syncEngine.execute(parsedCommand);
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "completed");
-            sync_logger_1.syncLogger.command(parsedCommand, "completed", {
+            await updateCommandStatus(db, command.command_id, "completed");
+            syncLogger.command(parsedCommand, "completed", {
                 event_count: events.length,
             });
-            sync_logger_1.syncLogger.info("CommandQueueService", "Queued command replayed", {
+            syncLogger.info("CommandQueueService", "Queued command replayed", {
                 command_id: command.command_id,
                 command_type: command.command_type,
                 event_count: events.length,
@@ -191,8 +188,8 @@ class CommandQueueService {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            await (0, operations_1.updateCommandStatus)(db, command.command_id, "failed", message);
-            sync_logger_1.syncLogger.command(parsedCommand, "failed", { error: message });
+            await updateCommandStatus(db, command.command_id, "failed", message);
+            syncLogger.command(parsedCommand, "failed", { error: message });
             throw error;
         }
     }
@@ -202,7 +199,7 @@ class CommandQueueService {
      */
     async replay() {
         if (this.replaying) {
-            sync_logger_1.syncLogger.debug("CommandQueueService", "Replay already in progress");
+            syncLogger.debug("CommandQueueService", "Replay already in progress");
             return;
         }
         this.replaying = true;
@@ -210,11 +207,11 @@ class CommandQueueService {
             // Await open (not getSyncDatabase) so a cold-start replay triggered by a
             // connectivity event that fires before the DB open completes does not
             // throw "Sync database not initialized".
-            const db = await (0, connection_1.openSyncDatabase)();
-            const pending = await (0, operations_1.getPendingCommands)(db);
+            const db = await openSyncDatabase();
+            const pending = await getPendingCommands(db);
             if (pending.length === 0)
                 return;
-            sync_logger_1.syncLogger.info("CommandQueueService", "Replaying commands", {
+            syncLogger.info("CommandQueueService", "Replaying commands", {
                 count: pending.length,
             });
             for (const command of pending) {
@@ -235,9 +232,9 @@ class CommandQueueService {
      * Cancel a queued command that has not yet been transmitted.
      */
     async cancel(commandId) {
-        const db = (0, connection_1.getSyncDatabase)();
-        await (0, operations_1.deleteCommand)(db, commandId);
-        sync_logger_1.syncLogger.debug("CommandQueueService", "Command cancelled", {
+        const db = getSyncDatabase();
+        await deleteCommand(db, commandId);
+        syncLogger.debug("CommandQueueService", "Command cancelled", {
             commandId,
         });
     }
@@ -245,9 +242,9 @@ class CommandQueueService {
      * Return the number of commands currently in the outbox.
      */
     async getPendingCount() {
-        const db = (0, connection_1.getSyncDatabase)();
-        const commands = await (0, operations_1.getPendingCommands)(db, Number.MAX_SAFE_INTEGER);
+        const db = getSyncDatabase();
+        const commands = await getPendingCommands(db, Number.MAX_SAFE_INTEGER);
         return commands.length;
     }
 }
-exports.commandQueueService = new CommandQueueService();
+export const commandQueueService = new CommandQueueService();

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-");
 }