@teincfood/core 0.7.9 → 0.8.1

package/dist/reference/menu-record.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Menu cache-record builders — the ONLY place MenuItem/MenuCategory records
+ * are constructed outside the backend.
+ *
+ * The reference cache holds backend-shaped records exactly as the serializer
+ * returns them (see TeincFoodBackend menu_serializer.ex). Form/mutation
+ * layers own every field at write time, so they build the record here —
+ * core never translates wire payloads into cache records.
+ */
+import type { MenuCategory, MenuItem } from "../types/api/menu.api";
+import type { QueryClient } from "@tanstack/react-query";
+export interface MenuItemRecordInput {
+    id?: string;
+    businessId: string;
+    name: string;
+    description?: string | null;
+    priceMinor: number;
+    currencyCode?: string;
+    categoryId: string;
+    categoryName?: string;
+    dietaryTags?: string[];
+    variants?: Array<{
+        id?: string;
+        name: string;
+        price_adjustment?: number;
+    }>;
+    extras?: Array<{
+        id?: string;
+        name: string;
+        price_minor?: number;
+    }>;
+    available?: boolean;
+    imageUrl?: string | null;
+    now?: string;
+}
+export declare function buildMenuItemRecord(input: MenuItemRecordInput): MenuItem;
+export interface MenuCategoryRecordInput {
+    id?: string;
+    name: string;
+    sort_order?: number;
+}
+export declare function buildMenuCategoryRecord(input: MenuCategoryRecordInput): MenuCategory;
+/** Every cached MenuItem for a business across cached + network queries. */
+export declare function getCachedMenuItems(qc: QueryClient, businessId: string): MenuItem[];
+export declare function getCachedMenuItem(qc: QueryClient, businessId: string, id: string): MenuItem | undefined;
+export declare function getCachedCategories(qc: QueryClient, businessId: string): MenuCategory[];
+export declare function getCachedCategoryName(qc: QueryClient, businessId: string, categoryId: string): string;
+export interface MenuItemEnvelopeInput extends MenuItemRecordInput {
+    /** Extra wire-only keys (e.g. entity id). */
+    wireExtra?: Record<string, unknown>;
+}
+/**
+ * Build the { wire, cacheRecord } pair for a menu item write. Callers pass
+ * backend adjustment-shaped variants; absolute form prices are converted by
+ * the caller (form layer owns both fields).
+ *
+ * Variant/extra ids are preserved when they are backend UUIDs. The backend
+ * update path deletes existing rows absent from the incoming list, so
+ * stripping ids on edit would wipe + recreate every variant/extra on each
+ * save (breaking any external references to those ids).
+ */
+export declare function buildMenuItemEnvelope(input: MenuItemEnvelopeInput): {
+    wire: Record<string, unknown>;
+    cacheRecord: MenuItem;
+};
+export declare function buildMenuCategoryEnvelope(input: MenuCategoryRecordInput): {
+    wire: Record<string, unknown>;
+    cacheRecord: MenuCategory;
+};

package/dist/reference/menu-record.js

@@ -0,0 +1,168 @@
+/**
+ * Menu cache-record builders — the ONLY place MenuItem/MenuCategory records
+ * are constructed outside the backend.
+ *
+ * The reference cache holds backend-shaped records exactly as the serializer
+ * returns them (see TeincFoodBackend menu_serializer.ex). Form/mutation
+ * layers own every field at write time, so they build the record here —
+ * core never translates wire payloads into cache records.
+ */
+import { generateUUID } from "../utils/uuid";
+import { CATALOG_KEYS } from "../catalog/hooks";
+import { toStorableImageUrl } from "../image-cache/service";
+export function buildMenuItemRecord(input) {
+    const currencyCode = input.currencyCode || "GHS";
+    const now = input.now ?? new Date().toISOString();
+    return {
+        id: input.id ?? generateUUID(),
+        name: input.name,
+        description: input.description ?? null,
+        basePrice: { amountMinor: input.priceMinor, currencyCode },
+        // Never persist preview URIs (tfimg:/blob:/file:): the backend stores
+        // non-http values verbatim and they poison every other device.
+        image_url: toStorableImageUrl(input.imageUrl),
+        is_available: input.available ?? true,
+        dietary_tags: input.dietaryTags ?? [],
+        category_id: input.categoryId,
+        business_id: input.businessId,
+        category: { id: input.categoryId, name: input.categoryName ?? "" },
+        variants: (input.variants ?? []).map((v) => ({
+            id: v.id ?? generateUUID(),
+            name: v.name,
+            // Matches backend serializer: variant price = base + adjustment.
+            price: { amountMinor: input.priceMinor + (v.price_adjustment ?? 0), currencyCode },
+        })),
+        extras: (input.extras ?? []).map((e) => ({
+            id: e.id ?? generateUUID(),
+            name: e.name,
+            pricingType: "fixed",
+            amountMinor: e.price_minor ?? 0,
+            currencyCode,
+        })),
+        inserted_at: now,
+        updated_at: now,
+    };
+}
+export function buildMenuCategoryRecord(input) {
+    return {
+        id: input.id ?? generateUUID(),
+        name: input.name,
+        sort_order: input.sort_order ?? 0,
+        is_global: false,
+        is_system: false,
+        pending_global_request: false,
+    };
+}
+// ─── Cache lookups (mutation layers read current records to build envelopes)
+function collectItems(blob, out) {
+    if (!blob || typeof blob !== "object")
+        return;
+    if (Array.isArray(blob)) {
+        for (const i of blob)
+            if (i?.id)
+                out.push(i);
+        return;
+    }
+    const rec = blob;
+    if (Array.isArray(rec.data))
+        collectItems(rec.data, out);
+    if (Array.isArray(rec.pages))
+        for (const p of rec.pages)
+            collectItems(p?.data, out);
+}
+/** Every cached MenuItem for a business across cached + network queries. */
+export function getCachedMenuItems(qc, businessId) {
+    const out = [];
+    try {
+        for (const [, data] of qc.getQueriesData({ queryKey: CATALOG_KEYS.items(businessId) })) {
+            collectItems(data, out);
+        }
+    }
+    catch { }
+    const seen = new Set();
+    return out.filter((i) => (seen.has(i.id) ? false : (seen.add(i.id), true)));
+}
+export function getCachedMenuItem(qc, businessId, id) {
+    return getCachedMenuItems(qc, businessId).find((i) => i.id === id);
+}
+function collectCategories(blob, out) {
+    if (!blob || typeof blob !== "object")
+        return;
+    if (Array.isArray(blob)) {
+        for (const c of blob)
+            if (c?.id)
+                out.push(c);
+        return;
+    }
+    const rec = blob;
+    if (Array.isArray(rec.data))
+        collectCategories(rec.data, out);
+}
+export function getCachedCategories(qc, businessId) {
+    const out = [];
+    try {
+        for (const [, data] of qc.getQueriesData({ queryKey: CATALOG_KEYS.categories(businessId) })) {
+            collectCategories(data, out);
+        }
+    }
+    catch { }
+    const seen = new Set();
+    return out.filter((c) => (seen.has(c.id) ? false : (seen.add(c.id), true)));
+}
+export function getCachedCategoryName(qc, businessId, categoryId) {
+    return getCachedCategories(qc, businessId).find((c) => c.id === categoryId)?.name ?? "";
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * A variant/extra id is only safe to send when it is a real backend UUID.
+ * Form-local ids (e.g. `local-<ts>`) must be omitted: the backend treats a
+ * missing/empty id as "insert new", but Repo.get/3 raises on a non-UUID.
+ */
+function wireId(id) {
+    return id && UUID_RE.test(id) ? id : undefined;
+}
+/**
+ * Build the { wire, cacheRecord } pair for a menu item write. Callers pass
+ * backend adjustment-shaped variants; absolute form prices are converted by
+ * the caller (form layer owns both fields).
+ *
+ * Variant/extra ids are preserved when they are backend UUIDs. The backend
+ * update path deletes existing rows absent from the incoming list, so
+ * stripping ids on edit would wipe + recreate every variant/extra on each
+ * save (breaking any external references to those ids).
+ */
+export function buildMenuItemEnvelope(input) {
+    const id = input.id ?? generateUUID();
+    const cacheRecord = buildMenuItemRecord({ ...input, id });
+    const wire = {
+        id,
+        name: input.name,
+        description: input.description ?? "",
+        price_minor: input.priceMinor,
+        category_id: input.categoryId,
+        currency_code: input.currencyCode ?? "GHS",
+        dietary_tags: input.dietaryTags ?? [],
+        variants: (input.variants ?? []).map((v) => {
+            const vid = wireId(v.id);
+            return vid
+                ? { id: vid, name: v.name, price_adjustment: v.price_adjustment ?? 0 }
+                : { name: v.name, price_adjustment: v.price_adjustment ?? 0 };
+        }),
+        extras: (input.extras ?? []).map((e) => {
+            const eid = wireId(e.id);
+            return eid
+                ? { id: eid, name: e.name, price_minor: e.price_minor ?? 0 }
+                : { name: e.name, price_minor: e.price_minor ?? 0 };
+        }),
+        available: input.available ?? true,
+        // Same storable rule as the cache record: preview URIs must not reach
+        // the backend (it stores them verbatim).
+        image_url: toStorableImageUrl(input.imageUrl),
+        ...(input.wireExtra ?? {}),
+    };
+    return { wire, cacheRecord };
+}
+export function buildMenuCategoryEnvelope(input) {
+    const cacheRecord = buildMenuCategoryRecord(input);
+    return { wire: { id: cacheRecord.id, name: input.name, ...(input.sort_order !== undefined ? { sort_order: input.sort_order } : {}) }, cacheRecord };
+}

package/dist/reference/operations.d.ts

@@ -3,6 +3,7 @@
  */
 import type { SQLiteDatabase } from "../adapters/sqlite";
 import type { ReferenceDataKey, ReferenceDataRecord } from "./types";
+import type { OperatingHoursEntry } from "../types/api/business.api";
 export declare function getReferenceData<T>(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<ReferenceDataRecord<T> | null>;
 export declare function getReferenceVersion(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<string | null>;
 export declare function setReferenceData<T>(db: SQLiteDatabase, businessId: string, record: ReferenceDataRecord<T>): Promise<void>;
@@ -10,3 +11,5 @@ export declare function mergeReferenceData<T extends Record<string, unknown>>(db
 export declare function deleteReferenceData(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<void>;
 export declare function deleteReferenceDataForBusiness(db: SQLiteDatabase, businessId: string): Promise<void>;
 export declare function getAllReferenceDataKeys(db: SQLiteDatabase, businessId: string): Promise<ReferenceDataKey[]>;
+export declare function setOperatingHoursLocal(businessId: string, entries: OperatingHoursEntry[]): Promise<void>;
+export declare function setBusinessProfileLocal(businessId: string, profile: Record<string, unknown>): Promise<void>;

package/dist/reference/operations.js

@@ -1,6 +1,11 @@
 /**
  * SQLite operations for the business-scoped reference data cache.
  */
+import { compareHLCString, hlcToString, tickHLC, hlcFromString } from "../utils/hlc";
+import { generateUUID } from "../utils/uuid";
+import { openSyncDatabase } from "../db/connection";
+import { getAppInstanceId } from "../adapters/devices";
+import { notifyDbChange } from "../db/operations";
 export async function getReferenceData(db, businessId, key) {
     const row = await db.getFirstAsync("SELECT * FROM reference_data WHERE business_id = ? AND key = ?;", businessId, key);
     if (!row)
@@ -29,9 +34,9 @@ export async function setReferenceData(db, businessId, record) {
         last_event_id = excluded.last_event_id,
         last_hlc = excluded.last_hlc;
     `, businessId, record.key, record.version, JSON.stringify(record.payload), record.downloadedAt, record.lastEventId ?? null, record.lastHlc ?? null);
+    notifyDbChange(businessId, `reference_data:${record.key}`);
 }
 export async function mergeReferenceData(db, businessId, key, incoming, hlc, eventId) {
-    const { compareHLCString } = await import("../utils/hlc");
     const existing = await getReferenceData(db, businessId, key);
     if (!existing) {
         await setReferenceData(db, businessId, {
@@ -68,3 +73,32 @@ export async function getAllReferenceDataKeys(db, businessId) {
     const rows = await db.getAllAsync("SELECT key FROM reference_data WHERE business_id = ? ORDER BY key;", businessId);
     return rows.map((r) => r.key);
 }
+async function enqueueReferenceSyncJob(businessId, key, hlc) {
+    try {
+        const db = await openSyncDatabase();
+        const id = generateUUID();
+        const now = new Date().toISOString();
+        await db.runAsync(`INSERT OR IGNORE INTO sync_jobs (id, business_id, command_type, entity_id, payload, status, created_at, updated_at, attempts, last_error) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?, 0, NULL);`, id, businessId, "reference:sync", key, JSON.stringify({ key, hlc }), now, now);
+    }
+    catch { }
+}
+export async function setOperatingHoursLocal(businessId, entries) {
+    const db = await openSyncDatabase();
+    const payload = { data: entries };
+    const now = new Date().toISOString();
+    // HLC ensures local edit wins over stale server pull via LWW
+    const existing = await getReferenceData(db, businessId, "operating-hours");
+    const lastHlc = existing?.lastHlc ? hlcFromString(existing.lastHlc) : null;
+    const hlcStr = hlcToString(tickHLC(Date.now(), lastHlc, getAppInstanceId()));
+    await mergeReferenceData(db, businessId, "operating-hours", payload, hlcStr, `evt_${hlcStr}`);
+    await enqueueReferenceSyncJob(businessId, "operating-hours", hlcStr);
+}
+export async function setBusinessProfileLocal(businessId, profile) {
+    const db = await openSyncDatabase();
+    const payload = { data: profile };
+    const existing = await getReferenceData(db, businessId, "business:profile");
+    const lastHlc = existing?.lastHlc ? hlcFromString(existing.lastHlc) : null;
+    const hlcStr = hlcToString(tickHLC(Date.now(), lastHlc, getAppInstanceId()));
+    await mergeReferenceData(db, businessId, "business:profile", payload, hlcStr, `evt_${hlcStr}`);
+    await enqueueReferenceSyncJob(businessId, "business:profile", hlcStr);
+}

package/dist/reference/service.js

@@ -12,7 +12,8 @@ import { syncLogger } from "../utils/sync-logger";
 import { generateUUID } from "../utils/uuid";
 import { menuService, businessService, rolesService } from "../adapters/services";
 import { cacheImageBatch, pruneImageCache } from "../adapters/image-cache";
-import { getReferenceData, getReferenceVersion, setReferenceData, } from "./operations";
+import { getConnectivityState } from "../adapters/connectivity";
+import { getReferenceData, getReferenceVersion, mergeReferenceData, } from "./operations";
 import { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, } from "./api";
 const DEFAULT_SYNC_KEYS = [
     "menu:items",
@@ -22,6 +23,8 @@ const DEFAULT_SYNC_KEYS = [
     "tax-rules",
     "business:profile",
     "operating-hours",
+    "delivery-settings",
+    "payment-settings",
     "subscription:entitlements",
     "capabilities",
 ];
@@ -38,6 +41,20 @@ class ReferenceSyncService {
                 errors: {},
             };
         }
+        const { isOnline, isCloudReachable } = getConnectivityState();
+        if (!isOnline || isCloudReachable === "unreachable") {
+            syncLogger.debug("ReferenceSync", "Skipping sync — cloud not reachable", {
+                businessId: options.businessId,
+                isOnline,
+                isCloudReachable,
+            });
+            return {
+                synced: [],
+                skipped: options.keys ?? DEFAULT_SYNC_KEYS,
+                failed: [],
+                errors: {},
+            };
+        }
         this.isSyncing = true;
         syncLogger.info("ReferenceSync", "Starting reference data sync", {
             businessId: options.businessId,
@@ -143,14 +160,9 @@ class ReferenceSyncService {
             payload = fallback.payload;
             version = fallback.version;
         }
-        await setReferenceData(db, businessId, {
-            key,
-            version: version ?? generateUUID(),
-            payload,
-            downloadedAt: new Date().toISOString(),
-            lastHlc: version ?? generateUUID(),
-            lastEventId: `evt_${version ?? generateUUID()}`,
-        });
+        // LWW: newer HLC wins — local edits that are newer than server are preserved.
+        const hlc = version ?? generateUUID();
+        await mergeReferenceData(db, businessId, key, payload, hlc, `evt_${hlc}`);
         return true;
     }
     async fetchFallback(key, businessId) {
@@ -244,6 +256,21 @@ class ReferenceSyncService {
                     version: this.hashPayload(response),
                 };
             }
+            case "delivery-settings": {
+                const response = await businessService.fetchDeliverySettings?.(businessId) ?? (await (await import("../adapters/http")).getHttpClient().get(`/businesses/${businessId}/delivery-settings`).then((r) => r.data));
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "payment-settings": {
+                const response = await businessService.fetchBusinessById(businessId);
+                const payload = response?.data?.paymentSettings ?? response;
+                return {
+                    payload,
+                    version: this.hashPayload(payload),
+                };
+            }
             default:
                 throw new Error(`No fallback fetch available for ${key}`);
         }

package/dist/reference/types.d.ts

@@ -8,7 +8,7 @@
  * It is synchronized separately from transactional data through the
  * ReferenceSyncService.
  */
-export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "subscription:entitlements" | "capabilities";
+export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "delivery-settings" | "payment-settings" | "subscription:entitlements" | "capabilities";
 export interface ReferenceDataRecord<T = unknown> {
     key: ReferenceDataKey;
     version: string;

package/dist/repositories/order.repository.d.ts

@@ -24,6 +24,13 @@ export interface OrderActionInput {
     businessId: string;
 }
 export declare const orderRepository: {
+    /**
+     * Single create path: build an `order:create` command and route it through
+     * the SyncEngine (cloud → LAN node → queue). Every path returns an
+     * order-shaped payload: cloud/LAN execute the real create, queue returns
+     * the optimistic order (same UUID + DD-RRR-CCC, replayed idempotently).
+     * Direct `createLocalOrder` bypasses sync — never call it from UI flows.
+     */
     createOrder(input: CreateOrderInput): Promise<SellerOrder>;
     acceptOrder(input: OrderActionInput): Promise<SellerOrder>;
     rejectOrder(input: OrderActionInput): Promise<SellerOrder>;

package/dist/repositories/order.repository.js

@@ -9,6 +9,7 @@
  */
 import { syncEngine } from "../sync/engine";
 import { buildCommand } from "../sync/command-builder";
+import { generateUUID } from "../utils/uuid";
 async function executeCommand(command) {
     console.debug("[OrderRepository] Dispatching command", JSON.stringify({
         command_id: command.command_id,
@@ -35,12 +36,24 @@ async function executeCommand(command) {
     return event.payload;
 }
 export const orderRepository = {
+    /**
+     * Single create path: build an `order:create` command and route it through
+     * the SyncEngine (cloud → LAN node → queue). Every path returns an
+     * order-shaped payload: cloud/LAN execute the real create, queue returns
+     * the optimistic order (same UUID + DD-RRR-CCC, replayed idempotently).
+     * Direct `createLocalOrder` bypasses sync — never call it from UI flows.
+     */
     async createOrder(input) {
+        const entityId = input.entityId ?? generateUUID();
         const command = buildCommand({
             commandType: "order:create",
             businessId: input.businessId,
-            entityId: input.entityId,
-            payload: input.data,
+            entityId,
+            payload: {
+                ...input.data,
+                id: entityId,
+                command_id: entityId,
+            },
         });
         return executeCommand(command);
     },

package/dist/repositories/pos.repository.d.ts

@@ -14,6 +14,10 @@ export interface POSOrderPreviewInput {
     customerName?: string;
 }
 export declare const posRepository: {
+    /**
+     * @deprecated Single create path is `createLocalOrder` (domain/orders/service).
+     * Forwards via `orderRepository.createOrder`, which delegates there directly.
+     */
     createOrder(businessId: string, data: POSOrderCreateRequest, entityId?: string): Promise<SellerOrder>;
     fetchPreview(input: POSOrderPreviewInput): Promise<POSOrderPreviewResponse>;
     fetchOrders(businessId: string, params?: Record<string, string>): Promise<SellerOrdersResponse>;

package/dist/repositories/pos.repository.js

@@ -7,6 +7,10 @@
 import { posService } from "../adapters/services";
 import { orderRepository } from "./order.repository";
 export const posRepository = {
+    /**
+     * @deprecated Single create path is `createLocalOrder` (domain/orders/service).
+     * Forwards via `orderRepository.createOrder`, which delegates there directly.
+     */
     async createOrder(businessId, data, entityId) {
         return orderRepository.createOrder({ businessId, data, entityId });
     },

package/dist/sync/backoff.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared retry backoff — one curve everywhere (sync retries, probes stay fixed).
+ *
+ * delay(attempts) = min(MAX, BASE * 2^attempts) + jitter(±20%).
+ * Attempts reset on any success or connectivity regain, so one bad night
+ * never permanently slows the device, and a fleet doesn't thunder-herd a
+ * recovering backend at the same millisecond.
+ */
+export declare const BACKOFF_BASE_MS = 2000;
+export declare const BACKOFF_MAX_MS: number;
+export declare function backoffDelayMs(attempts: number): number;
+/** Deterministic center of the curve (no jitter) — for tests and logging. */
+export declare function backoffCenterMs(attempts: number): number;
+/** Attempt counters keyed by scope (e.g. business id). Reset on success/regain. */
+export declare class BackoffTracker {
+    private attempts;
+    next(scope: string): number;
+    reset(scope: string): void;
+    resetAll(): void;
+    count(scope: string): number;
+}

package/dist/sync/backoff.js

@@ -0,0 +1,42 @@
+/**
+ * Shared retry backoff — one curve everywhere (sync retries, probes stay fixed).
+ *
+ * delay(attempts) = min(MAX, BASE * 2^attempts) + jitter(±20%).
+ * Attempts reset on any success or connectivity regain, so one bad night
+ * never permanently slows the device, and a fleet doesn't thunder-herd a
+ * recovering backend at the same millisecond.
+ */
+export const BACKOFF_BASE_MS = 2000;
+export const BACKOFF_MAX_MS = 5 * 60000;
+const JITTER_RATIO = 0.2;
+export function backoffDelayMs(attempts) {
+    const safe = Math.max(0, Math.floor(attempts));
+    const capped = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * Math.pow(2, safe));
+    const jitter = capped * JITTER_RATIO * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(capped + jitter));
+}
+/** Deterministic center of the curve (no jitter) — for tests and logging. */
+export function backoffCenterMs(attempts) {
+    const safe = Math.max(0, Math.floor(attempts));
+    return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * Math.pow(2, safe));
+}
+/** Attempt counters keyed by scope (e.g. business id). Reset on success/regain. */
+export class BackoffTracker {
+    constructor() {
+        this.attempts = new Map();
+    }
+    next(scope) {
+        const n = this.attempts.get(scope) ?? 0;
+        this.attempts.set(scope, n + 1);
+        return backoffDelayMs(n);
+    }
+    reset(scope) {
+        this.attempts.delete(scope);
+    }
+    resetAll() {
+        this.attempts.clear();
+    }
+    count(scope) {
+        return this.attempts.get(scope) ?? 0;
+    }
+}

package/dist/sync/command-builder.js

@@ -11,6 +11,14 @@ export function buildCommand(options) {
     const user = useAuthStore.getState().user;
     const userId = user?.id ?? "anonymous";
     const deviceId = getAppInstanceId();
+    const timestamp = new Date().toISOString();
+    // Inject inserted_at / updated_at into payload so the backend preserves the
+    // original client creation time for offline-first sync.
+    const payload = {
+        ...options.payload,
+        inserted_at: timestamp,
+        updated_at: timestamp,
+    };
     return {
         command_id: generateCommandId(),
         command_type: options.commandType,
@@ -19,8 +27,8 @@ export function buildCommand(options) {
         entity_id: options.entityId,
         user_id: userId,
         device_id: deviceId,
-        timestamp: new Date().toISOString(),
-        payload: options.payload,
+        timestamp,
+        payload,
     };
 }
 export { getAppInstanceId };

package/dist/sync/command-queue.service.d.ts

@@ -37,6 +37,18 @@ declare class CommandQueueService {
      * Return the number of commands currently in the outbox.
      */
     getPendingCount(): Promise<number>;
+    /**
+     * Debug dump of the engine outbox for Diagnostics screens (all statuses,
+     * newest last). Mirrors debugDumpSyncJobs.
+     */
+    debugDumpCommands(businessId: string): Promise<Array<{
+        id: string;
+        command_type: string;
+        status: string;
+        retry_count: number;
+        error: string | null;
+        created_at: string;
+    }>>;
 }
 export declare const commandQueueService: CommandQueueService;
 export {};