@teincfood/core 0.9.11 → 0.9.14

package/dist/domain/orders/service.js

@@ -14,6 +14,7 @@ import { assertBusinessOpenForCreate } from "../../utils/business-hours";
 import { canTransition } from "../../utils/order-transitions";
 import { TRANSITION_ERROR_CODES, TransitionError } from "../../sync/transition-errors";
 import { validateOrderCreateInput } from "../../validation/offline";
+import { buildItemSnapshots, snapshotsToOrderLines } from "./snapshots";
 import { drainOne, pullRemoteOrders } from "../../sync/sync-jobs.service";
 import { getAuthToken } from "../../adapters/auth";
 import { canBusinessSync } from "../../sync/sync-guard";
@@ -106,9 +107,12 @@ export async function createLocalOrder(businessId, input) {
     // while offline retain their original creation time.
     const now = new Date().toISOString();
     const insertedAt = input.inserted_at || now;
-    // item_snapshots from CartPanel, else fallback
-    const snapshots = input.item_snapshots;
-    const items = snapshots ? snapshots.map((s, i) => ({ id: `tmp-${id}-${i}`, menu_item: { id: s.menu_item_id, name: s.name }, quantity: s.quantity, unit_price: s.unit_price_minor, subtotal: s.unit_price_minor * s.quantity })) : (input.items ?? []).map((it, i) => ({ id: `tmp-${id}-${i}`, menu_item: { id: it.menu_item_id, name: "" }, quantity: it.quantity, unit_price: 0, subtotal: 0 }));
+    // Sale-time snapshots (canonical builder): names are embedded once and
+    // never re-resolved from the menu cache — offline history is self-contained.
+    const snapshots = buildItemSnapshots(input.item_snapshots ??
+        input.items ??
+        []);
+    const items = snapshotsToOrderLines(snapshots, id);
     const totalMinor = input.total_minor ?? 0;
     const subtotalMinor = input.subtotal_minor ?? totalMinor;
     const taxMinor = input.tax_minor ?? 0;

package/dist/domain/orders/snapshots.d.ts

@@ -0,0 +1,72 @@
+import type { OrderItem } from "../../types/api/seller.api";
+/**
+ * Order Item Snapshots — the single contract for sale-time history.
+ *
+ * Every order line carries its own immutable snapshot (item/variant/addon
+ * names as of sale time) so order history never depends on the live menu:
+ * sizes, extras, and items can be renamed or deleted without touching past
+ * orders — on any client, online or offline.
+ *
+ * Both POS apps build their outbox payloads through `buildItemSnapshots`:
+ * it accepts either app's cart-line shape (rich lines with
+ * `selected_variant`/`selected_addons`, or thin lines with just the menu
+ * item) plus already-built snapshots (idempotent), and always emits the
+ * full canonical shape. The local order builders and the offline receipt
+ * renderer consume only this shape — they never re-resolve names from the
+ * menu cache.
+ */
+export interface SnapshotAddon {
+    name: string;
+    price_minor: number;
+}
+export interface OrderItemSnapshot {
+    menu_item_id: string;
+    name: string;
+    quantity: number;
+    unit_price_minor: number;
+    variant_id?: string;
+    variant_name?: string;
+    addons: SnapshotAddon[];
+}
+/** Cart line shapes from the POS apps (superset tolerated). */
+export interface SnapshotCartLine {
+    menu_item?: {
+        id: string;
+        name: string;
+    } | null;
+    menu_item_id?: string;
+    name?: string;
+    quantity?: number;
+    unit_price_minor?: number;
+    unit_price?: number;
+    subtotal?: number;
+    selected_variant?: {
+        id?: string;
+        name?: string;
+    } | null;
+    variant_id?: string;
+    variant_name?: string;
+    selected_addons?: Array<{
+        addon_id?: string;
+        id?: string;
+        name?: string;
+        price_minor?: number;
+        price?: number;
+    }> | null;
+    addons?: Array<{
+        name?: string;
+        price_minor?: number;
+        price?: number;
+    }> | null;
+}
+/**
+ * Normalize any POS cart line (or an already-built snapshot) into the
+ * canonical snapshot. Missing variant/addon info yields `undefined` / `[]`
+ * — never a menu-cache lookup.
+ */
+export declare function buildItemSnapshots(lines: SnapshotCartLine[] | null | undefined): OrderItemSnapshot[];
+/**
+ * Expand snapshots into local order-line objects (the `SellerOrder["items"]`
+ * shape): names embedded, ids kept for reference, zero menu lookups.
+ */
+export declare function snapshotsToOrderLines(snapshots: OrderItemSnapshot[] | null | undefined, commandId: string): OrderItem[];

package/dist/domain/orders/snapshots.js

@@ -0,0 +1,68 @@
+function asString(value) {
+    return typeof value === "string" ? value : "";
+}
+function asNumber(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+/**
+ * Normalize any POS cart line (or an already-built snapshot) into the
+ * canonical snapshot. Missing variant/addon info yields `undefined` / `[]`
+ * — never a menu-cache lookup.
+ */
+export function buildItemSnapshots(lines) {
+    if (!Array.isArray(lines))
+        return [];
+    return lines.map((line) => {
+        const menuItemId = asString(line.menu_item?.id ?? line.menu_item_id);
+        const name = asString(line.menu_item?.name ?? line.name);
+        const quantity = asNumber(line.quantity, 1);
+        const unitPrice = asNumber(line.unit_price_minor ?? line.unit_price, 0);
+        const subtotal = asNumber(line.subtotal, unitPrice * quantity);
+        const variantId = line.selected_variant?.id ?? line.variant_id;
+        const variantName = line.selected_variant?.name ?? line.variant_name;
+        const rawAddons = line.selected_addons ?? line.addons ?? [];
+        const addons = Array.isArray(rawAddons)
+            ? rawAddons.map((a) => ({
+                name: asString(a.name),
+                price_minor: asNumber(a.price_minor ?? a.price, 0),
+            }))
+            : [];
+        const explicitPrice = line.unit_price_minor ?? line.unit_price;
+        const unitPriceMinor = typeof explicitPrice === "number" && Number.isFinite(explicitPrice)
+            ? explicitPrice
+            : subtotal && quantity
+                ? Math.round(subtotal / quantity)
+                : 0;
+        const snapshot = {
+            menu_item_id: menuItemId,
+            name,
+            quantity,
+            unit_price_minor: unitPriceMinor,
+            addons,
+        };
+        if (variantId)
+            snapshot.variant_id = variantId;
+        if (typeof variantName === "string" && variantName !== "")
+            snapshot.variant_name = variantName;
+        return snapshot;
+    });
+}
+/**
+ * Expand snapshots into local order-line objects (the `SellerOrder["items"]`
+ * shape): names embedded, ids kept for reference, zero menu lookups.
+ */
+export function snapshotsToOrderLines(snapshots, commandId) {
+    if (!Array.isArray(snapshots))
+        return [];
+    return snapshots.map((s, index) => ({
+        id: `tmp-${commandId}-${index}`,
+        menu_item: { id: s.menu_item_id, name: s.name },
+        quantity: s.quantity,
+        unit_price: s.unit_price_minor,
+        subtotal: s.unit_price_minor * s.quantity,
+        variant_id: s.variant_id ?? null,
+        variant_name: s.variant_name ?? null,
+        variant: s.variant_name ? { id: s.variant_id, name: s.variant_name } : null,
+        addons: (s.addons ?? []).map((a) => ({ name: a.name, price_minor: a.price_minor })),
+    }));
+}

package/dist/index.d.ts

@@ -135,6 +135,7 @@ export * from "./sync/transition-endpoints";
 export * from "./utils/business-hours";
 export * from "./hooks/business-hours.hooks";
 export * from "./domain/orders/service";
+export * from "./domain/orders/snapshots";
 export { phoenixSocket } from "./realtime/phoenix-socket";
 export { eventsService } from "./realtime/events.service";
 export { orderEventsService } from "./realtime/order-events.service";

package/dist/index.js

@@ -148,6 +148,7 @@ export * from "./hooks/business-hours.hooks";
 // components/OrderStatusCard was folded into order-transitions (compat re-export lives in apps)
 // ── Domain (offline-first primary DB) ──
 export * from "./domain/orders/service";
+export * from "./domain/orders/snapshots";
 // ── Realtime (single source — PHX WebSocket + business:{id}) ──
 export { phoenixSocket } from "./realtime/phoenix-socket";
 export { eventsService } from "./realtime/events.service";

package/dist/printer/receipt.js

@@ -161,6 +161,11 @@ export function calloutNumber(order) {
     return String(parseInt(digits, 10));
 }
 function itemName(item) {
+    // Snapshot-first: the sale-time name survives menu renames/deletes.
+    // The embedded menu join is fallback for pre-snapshot rows.
+    const snapshot = item.name;
+    if (typeof snapshot === "string" && snapshot !== "")
+        return snapshot;
     return item.menu_item?.name || "(deleted item)";
 }
 function addonName(addon) {
@@ -171,6 +176,11 @@ function addonName(addon) {
     return "Add-on";
 }
 function variantName(item) {
+    // Snapshot-first: the sale-time size name survives menu edits. The live
+    // variant join is fallback for pre-snapshot rows.
+    const snapshot = item.variant_name;
+    if (typeof snapshot === "string" && snapshot !== "")
+        return snapshot;
     const n = item.variant?.name;
     return n ? n : null;
 }
@@ -431,6 +441,9 @@ export function generateEscpos(order, logoRasterB64) {
     push(LF);
     pushT(company.website + LF);
     pushT(`Powered by ${company.name}` + LF);
+    // Trailing space before the blade: feed past the print head so the cut
+    // never slices the last footer line.
+    push(ESC_FEED_3);
     push(ESC_FEED_3);
     push(GS_CUT_FULL);
     return parts.filter((p) => p != null).join("");

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

@@ -16,6 +16,7 @@ import { TransitionError, isReplayDeferred, TRANSITION_ERROR_CODES } from "./tra
 import { assertBusinessOpenForCreate } from "../utils/business-hours";
 import { extractApiErrorCode } from "../utils/error";
 import { generateEventId } from "../utils/uuid";
+import { buildItemSnapshots, snapshotsToOrderLines } from "../domain/orders/snapshots";
 import { generateLocalCalloutNumber, generateOrderNumberForBusiness, generateOrderNumber, } from "./order-number";
 import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
 import { canBusinessSync } from "./sync-guard";
@@ -102,8 +103,7 @@ function buildOptimisticEvent(command) {
     };
 }
 function buildOptimisticOrder(command, payload) {
-    const snapshots = payload.item_snapshots ?? null;
-    const items = payload.items ?? [];
+    const snapshots = buildItemSnapshots((payload.item_snapshots ?? payload.items ?? []));
     const totalMinor = payload.total_minor ?? 0;
     const subtotalMinor = payload.subtotal_minor ?? totalMinor;
     const taxMinor = payload.tax_minor ?? 0;
@@ -149,22 +149,7 @@ function buildOptimisticOrder(command, payload) {
         delivery_lat: null,
         delivery_lng: null,
         user: null,
-        items: (snapshots ? snapshots.map((s, index) => ({
-            id: `tmp-${command.command_id}-${index}`,
-            menu_item: { id: s.menu_item_id, name: s.name },
-            quantity: s.quantity,
-            unit_price: s.unit_price_minor,
-            subtotal: s.unit_price_minor * s.quantity,
-            variant_name: s.variant_name,
-            addons: (s.addons ?? []).map((a) => ({ name: a.name, price_minor: a.price_minor })),
-        })) : items.map((item, index) => ({
-            id: `tmp-${command.command_id}-${index}`,
-            menu_item: { id: item.menu_item_id, name: "" },
-            quantity: item.quantity,
-            unit_price: 0,
-            subtotal: 0,
-            addons: [],
-        }))),
+        items: snapshotsToOrderLines(snapshots, command.command_id),
         inserted_at: now,
     };
 }

package/dist/sync/engine.d.ts

@@ -48,7 +48,6 @@ export declare class SyncEngine {
      */
     publish(event: DomainEvent): void;
     private resolveStrategy;
-    private selectTransport;
     private broadcast;
 }
 export declare const syncEngine: SyncEngine;

package/dist/sync/engine.js

@@ -18,7 +18,7 @@ import { getConnectivityState } from "../adapters/connectivity";
 import { ApiError } from "../adapters/http";
 import { errorCodeOf } from "./transition-errors";
 import { syncLogger } from "../utils/sync-logger";
-import { CLOUD_COMMAND_TIMEOUT_MS } from "../utils/constants";
+import { CLOUD_COMMAND_TIMEOUT_MS, LAN_COMMAND_TIMEOUT_MS } from "../utils/constants";
 import { CAPABILITY_BY_COMMAND } from "../reference/capabilities";
 import { getReferenceData } from "../reference/operations";
 import { openSyncDatabase } from "../db/connection";
@@ -39,6 +39,17 @@ function withTimeout(promise, ms) {
         });
     });
 }
+/**
+ * Cash sales must never be refused for lack of entitlement proof: the POS
+ * domain defaults a missing method to cash, and only cash can be fulfilled
+ * without the backend. Anything else keeps the fail-closed guard.
+ */
+function isCashOrderCreate(command) {
+    if (command.command_type !== "order:create")
+        return false;
+    const method = command.payload?.pos_payment_method;
+    return method === undefined || method === "cash";
+}
 export class SyncEngine {
     constructor(options) {
         this.eventSubscribers = [];
@@ -80,89 +91,129 @@ export class SyncEngine {
                 // otherwise fail open
             }
         }
-        // Entitlement guard (fail-closed, offline-first): subscription-gated
-        // commands need cached proof before routing. Backend 402 backstops.
+        // Entitlement guard (offline-first): subscription-gated commands need
+        // cached proof before routing — EXCEPT cash order:create, which always
+        // queues so the terminal never refuses a sale offline. The backend 402
+        // remains the backstop at replay; the queued event is flagged so the
+        // pending list can badge it until the server confirms.
+        let queueDespiteEntitlement = false;
         try {
             await assertEntitledForCommand(command.business_id, command.command_type);
         }
         catch (e) {
             if (e instanceof TransitionError &&
                 e.code === TRANSITION_ERROR_CODES.SUBSCRIPTION_REQUIRED) {
-                throw e;
+                if (isCashOrderCreate(command)) {
+                    queueDespiteEntitlement = true;
+                    syncLogger.warn("SyncEngine", "queueing cash order without entitlement proof", {
+                        command_id: command.command_id,
+                        business_id: command.business_id,
+                    });
+                }
+                else {
+                    throw e;
+                }
+            }
+            else {
+                // Guard infra failure (no DB yet, corrupt cache) must not brick the
+                // terminal — backend remains the authority. Log and continue.
+                syncLogger.warn("SyncEngine", "entitlement guard skipped", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
             }
-            // Guard infra failure (no DB yet, corrupt cache) must not brick the
-            // terminal — backend remains the authority. Log and continue.
-            syncLogger.warn("SyncEngine", "entitlement guard skipped", {
-                error: e instanceof Error ? e.message : String(e),
-            });
         }
-        let strategy = this.resolveStrategy(command);
+        const initialStrategy = this.resolveStrategy(command);
         const { isCloudReachable, isOnline } = getConnectivityState();
         syncLogger.info("SyncEngine", "Command strategy resolved", {
             command_id: command.command_id,
             command_type: command.command_type,
-            strategy,
+            strategy: initialStrategy,
             isCloudReachable,
             isOnline,
             cloud_available: restTransport.isAvailable(),
             lan_available: localNodeTransport.isAvailable(),
         });
-        if (strategy === "queue") {
-            // Replays must never re-enqueue-then-delete (the command would eat
-            // itself without executing). If no real transport is available, leave
-            // the row untouched for a later trigger.
-            if (opts?.forReplay) {
-                throw new TransitionError(TRANSITION_ERROR_CODES.REPLAY_DEFERRED, "No transport available, keeping command queued");
-            }
-            const event = await commandQueueService.enqueue(command);
-            this.broadcast(event);
-            // Menu writes need a visible local effect while queued: patch the
-            // durable reference cache optimistically and fan out
-            // reference_data.changed so reconciliation applies it locally and
-            // relays it to LAN peers (replay re-applies idempotently; the backend
-            // owns versions on cloud convergence).
-            if (command.command_type.startsWith("menu:")) {
-                try {
-                    const { applyMenuCommandLocal } = await import("../reference/menu-apply");
-                    const { keys } = await applyMenuCommandLocal(command.business_id, command);
-                    if (keys.length) {
-                        const { REFERENCE_CHANGED_EVENT_TYPE } = await import("../reference/events");
-                        const { generateEventId } = await import("../utils/uuid");
-                        this.broadcast({
-                            event_id: generateEventId(),
-                            event_type: REFERENCE_CHANGED_EVENT_TYPE,
-                            event_version: "1.0",
-                            entity_id: command.business_id,
-                            user_id: command.user_id,
-                            device_id: command.device_id,
-                            payload: { business_id: command.business_id, keys },
-                            timestamp: new Date().toISOString(),
-                        });
-                    }
+        // Ordered attempts for THIS execution only. Every await below is capped,
+        // so the UI can never hang: a stale "reachable" belief may send the
+        // first attempt to a dead cloud, but it is tried ONCE (2.5s cap) and
+        // never re-entered — the command downgrades to LAN, then the outbox.
+        const attempts = initialStrategy === "cloud"
+            ? [
+                "cloud",
+                ...(localNodeTransport.isAvailable() ? ["local_node"] : []),
+                "queue",
+            ]
+            : initialStrategy === "local_node"
+                ? ["local_node", "queue"]
+                : ["queue"];
+        let lastError = null;
+        for (const attempt of attempts) {
+            if (attempt === "queue") {
+                // Replays must never re-enqueue-then-delete (the command would eat
+                // itself without executing). If no real transport is available, leave
+                // the row untouched for a later trigger.
+                if (opts?.forReplay) {
+                    throw new TransitionError(TRANSITION_ERROR_CODES.REPLAY_DEFERRED, "No transport available, keeping command queued");
                 }
-                catch (e) {
-                    syncLogger.debug("SyncEngine", "queued menu optimistic apply failed", { err: String(e) });
+                const event = await commandQueueService.enqueue(command);
+                if (queueDespiteEntitlement) {
+                    event.payload = {
+                        ...event.payload,
+                        entitlement_unverified: true,
+                    };
                 }
+                this.broadcast(event);
+                // Menu writes need a visible local effect while queued: patch the
+                // durable reference cache optimistically and fan out
+                // reference_data.changed so reconciliation applies it locally and
+                // relays it to LAN peers (replay re-applies idempotently; the backend
+                // owns versions on cloud convergence).
+                if (command.command_type.startsWith("menu:")) {
+                    try {
+                        const { applyMenuCommandLocal } = await import("../reference/menu-apply");
+                        const { keys } = await applyMenuCommandLocal(command.business_id, command);
+                        if (keys.length) {
+                            const { REFERENCE_CHANGED_EVENT_TYPE } = await import("../reference/events");
+                            const { generateEventId } = await import("../utils/uuid");
+                            this.broadcast({
+                                event_id: generateEventId(),
+                                event_type: REFERENCE_CHANGED_EVENT_TYPE,
+                                event_version: "1.0",
+                                entity_id: command.business_id,
+                                user_id: command.user_id,
+                                device_id: command.device_id,
+                                payload: { business_id: command.business_id, keys },
+                                timestamp: new Date().toISOString(),
+                            });
+                        }
+                    }
+                    catch (e) {
+                        syncLogger.debug("SyncEngine", "queued menu optimistic apply failed", { err: String(e) });
+                    }
+                }
+                return [event];
             }
-            return [event];
-        }
-        if (strategy === "cloud") {
+            const transport = attempt === "cloud" ? restTransport : localNodeTransport;
+            const cap = attempt === "cloud" ? CLOUD_COMMAND_TIMEOUT_MS : LAN_COMMAND_TIMEOUT_MS;
             try {
-                const events = await withTimeout(restTransport.execute(command), CLOUD_COMMAND_TIMEOUT_MS);
+                const events = await withTimeout(transport.execute(command), cap);
                 for (const event of events) {
                     this.broadcast(event);
                 }
                 syncLogger.command(command, "completed", {
                     event_count: events.length,
+                    transport: transport.name,
                 });
-                // Cloud just worked: replay anything queued during the outage.
-                // Flag-neutral: only the health probe writes isCloudReachable — a
-                // single success here is not its decision to make either.
-                this.replayQueuedCommands().catch((error) => {
-                    syncLogger.error("SyncEngine", "Replay after cloud success failed", {
-                        error: String(error),
+                if (attempt === "cloud") {
+                    // Cloud just worked: replay anything queued during the outage.
+                    // Flag-neutral: only the health probe writes isCloudReachable — a
+                    // single success here is not its decision to make either.
+                    this.replayQueuedCommands().catch((error) => {
+                        syncLogger.error("SyncEngine", "Replay after cloud success failed", {
+                            error: String(error),
+                        });
                     });
-                });
+                }
                 return events;
             }
             catch (error) {
@@ -190,60 +241,32 @@ export class SyncEngine {
                     ? error.status
                     : undefined;
                 if (rejectionStatus !== undefined && rejectionStatus >= 400 && rejectionStatus < 500) {
-                    syncLogger.warn("SyncEngine", "Cloud command rejected by server", {
+                    syncLogger.warn("SyncEngine", "Command rejected by server", {
                         command_type: command.command_type,
                         command_id: command.command_id,
+                        transport: transport.name,
                         status: rejectionStatus,
                         code,
                         message: error instanceof Error ? error.message : String(error),
                     });
                     throw error;
                 }
-                // Cloud is slow or unreachable: fall back to the Local Node or the
-                // outbox so the terminal stays responsive. Flag-neutral: only the
+                // Timeout or network error: downgrade to the next attempt (LAN, then
+                // outbox) so the terminal stays responsive. Flag-neutral: only the
                 // health probe writes isCloudReachable — a failed request is never
                 // evidence the cloud is down (it may be a logic rejection without a
                 // numeric status, e.g. TransitionError). The probe detects real
                 // outages; queued work replays when it reports recovery.
-                syncLogger.warn("SyncEngine", "Cloud command timed out, falling back", {
+                syncLogger.warn("SyncEngine", `${transport.name} attempt failed, downgrading`, {
                     command_type: command.command_type,
-                    error: String(error),
-                });
-                strategy = this.resolveStrategy(command);
-                if (strategy === "queue") {
-                    // Replays must never re-enqueue-then-delete (the command would eat
-                    // itself without executing). If no real transport is available, leave
-                    // the row untouched for a later trigger.
-                    if (opts?.forReplay) {
-                        throw new TransitionError(TRANSITION_ERROR_CODES.REPLAY_DEFERRED, "No transport available, keeping command queued");
-                    }
-                    const event = await commandQueueService.enqueue(command);
-                    this.broadcast(event);
-                    return [event];
-                }
-                syncLogger.info("SyncEngine", "Cloud timed out, using LAN fallback", {
                     command_id: command.command_id,
-                    command_type: command.command_type,
-                    strategy,
+                    error: String(error),
                 });
+                lastError = error;
             }
         }
-        const transport = this.selectTransport(command, strategy);
-        syncLogger.info("SyncEngine", "Executing via transport", {
-            command_id: command.command_id,
-            command_type: command.command_type,
-            strategy,
-            transport: transport.name,
-        });
-        const events = await transport.execute(command);
-        for (const event of events) {
-            this.broadcast(event);
-        }
-        syncLogger.command(command, "completed", {
-            event_count: events.length,
-            transport: transport.name,
-        });
-        return events;
+        // Unreachable: attempts always ends with "queue", which returns.
+        throw lastError ?? new Error("SyncEngine: no transport attempt succeeded");
     }
     /**
      * Trigger replay of queued commands when connectivity returns.
@@ -296,19 +319,6 @@ export class SyncEngine {
         }
         return "cloud";
     }
-    selectTransport(_command, strategy) {
-        if (strategy === "local_node" && localNodeTransport.isAvailable()) {
-            return localNodeTransport;
-        }
-        if (strategy === "cloud" && restTransport.isAvailable()) {
-            return restTransport;
-        }
-        const transport = this.transports.find((t) => t.isAvailable()) ?? this.transports[0];
-        if (!transport) {
-            throw new Error("SyncEngine: no transports configured");
-        }
-        return transport;
-    }
     broadcast(event) {
         syncLogger.event(event, "broadcast");
         this.eventSubscribers.forEach((handler) => handler(event));

package/dist/types/api/seller.api.d.ts

@@ -39,6 +39,8 @@ export interface OrderItem {
         id?: string;
         name?: string;
     } | null;
+    /** Sale-time size name snapshot — history never re-resolves the menu. */
+    variant_name?: string | null;
     /** Backend shape for addon lines. */
     order_item_addons?: OrderItemAddon[];
 }

package/dist/utils/constants.d.ts

@@ -49,6 +49,12 @@ export declare const DEFAULT_PAGE_SIZE = 20;
  * Keeps the terminal responsive (fast) even when the internet is slow.
  */
 export declare const CLOUD_COMMAND_TIMEOUT_MS = 2500;
+/**
+ * Max time the Sync Engine waits for a Local Node command before falling
+ * back to the offline outbox. LAN discovery can stall on a dead peer —
+ * this cap keeps every engine await bounded so the UI can never hang.
+ */
+export declare const LAN_COMMAND_TIMEOUT_MS = 5000;
 export declare const appVersion = "0.7.3";
 /** Default config bundle for createTeincCore overrides */
 export declare const DEFAULTS: {
@@ -84,4 +90,5 @@ export declare const DEFAULTS: {
     readonly OTP_RESEND_DELAY_SECONDS: 60;
     readonly DEFAULT_PAGE_SIZE: 20;
     readonly CLOUD_COMMAND_TIMEOUT_MS: 2500;
+    readonly LAN_COMMAND_TIMEOUT_MS: 5000;
 };

package/dist/utils/constants.js

@@ -77,6 +77,12 @@ export const DEFAULT_PAGE_SIZE = 20;
  * Keeps the terminal responsive (fast) even when the internet is slow.
  */
 export const CLOUD_COMMAND_TIMEOUT_MS = 2500;
+/**
+ * Max time the Sync Engine waits for a Local Node command before falling
+ * back to the offline outbox. LAN discovery can stall on a dead peer —
+ * this cap keeps every engine await bounded so the UI can never hang.
+ */
+export const LAN_COMMAND_TIMEOUT_MS = 5000;
 // Expo version removed; expose static version for now
 export const appVersion = APP_VERSION;
 /** Default config bundle for createTeincCore overrides */
@@ -92,4 +98,5 @@ export const DEFAULTS = {
     OTP_RESEND_DELAY_SECONDS,
     DEFAULT_PAGE_SIZE,
     CLOUD_COMMAND_TIMEOUT_MS,
+    LAN_COMMAND_TIMEOUT_MS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.9.11",
+  "version": "0.9.14",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",