@teincfood/core 0.1.4 → 0.1.6

package/dist/adapters/services.d.ts

@@ -46,6 +46,7 @@ export declare const businessService: {
     fetchBusinessTaxRules: (_businessId: string) => Promise<unknown>;
     fetchBusinessById: (_businessId: string) => Promise<unknown>;
     fetchOperatingHours: (_businessId: string) => Promise<unknown>;
+    fetchMyBusinessMembership: (_businessId: string) => Promise<unknown>;
 };
 export declare const rolesService: {
     fetchBusinessRoles: () => Promise<unknown>;

package/dist/adapters/services.js

@@ -81,6 +81,9 @@ export const businessService = {
     fetchOperatingHours: async (_businessId) => {
         notImpl("businessService.fetchOperatingHours");
     },
+    fetchMyBusinessMembership: async (_businessId) => {
+        notImpl("businessService.fetchMyBusinessMembership");
+    },
 };
 export const rolesService = {
     fetchBusinessRoles: async () => {

package/dist/index.d.ts

@@ -20,6 +20,8 @@ export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
 export * from "./utils/responsive";
 export * from "./utils/copyToClipBoard";
+export * from "./utils/customer-display";
+export * from "./utils/order-filter";
 export * from "./db/migrations";
 export * from "./db/operations";
 export * as dbOps from "./db/operations";
@@ -54,6 +56,7 @@ export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnRec
 export * from "./reference/events";
 export * from "./reference/service";
 export { referenceSyncService } from "./reference/service";
+export * from "./reference/capabilities";
 export * from "./adapters/sqlite";
 export * from "./adapters/kv";
 export * from "./adapters/connectivity";

package/dist/index.js

@@ -21,6 +21,8 @@ export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
 export * from "./utils/responsive";
 export * from "./utils/copyToClipBoard";
+export * from "./utils/customer-display";
+export * from "./utils/order-filter";
 // ── DB ──
 export * from "./db/migrations";
 export * from "./db/operations";
@@ -55,6 +57,7 @@ export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnRec
 export * from "./reference/events";
 export * from "./reference/service";
 export { referenceSyncService } from "./reference/service";
+export * from "./reference/capabilities";
 // ── Adapters (for host apps to supply) ──
 export * from "./adapters/sqlite";
 export * from "./adapters/kv";

package/dist/reference/capabilities.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Capabilities reference — offline-first.
+ *
+ * Standardises business-membership capabilities for both mobile and desktop.
+ * The backend `GET /businesses/:id/my-membership` is the source of truth;
+ * the result is mirrored to `reference_data` key `capabilities` so drawer/nav
+ * filtering works offline and survives restarts.
+ *
+ * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
+ */
+/**
+ * Standard hook for both apps — businessId comes from the host's active business store.
+ * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ */
+export declare function useBusinessCapabilities(businessId?: string | null): import("@tanstack/react-query").UseQueryResult<{
+    role: string;
+    source: string;
+    capabilities: string[];
+    status: string;
+}, Error>;
+export declare function useHasCapabilityFor(businessId: string | undefined, capability: string): boolean;

package/dist/reference/capabilities.js

@@ -0,0 +1,81 @@
+/**
+ * Capabilities reference — offline-first.
+ *
+ * Standardises business-membership capabilities for both mobile and desktop.
+ * The backend `GET /businesses/:id/my-membership` is the source of truth;
+ * the result is mirrored to `reference_data` key `capabilities` so drawer/nav
+ * filtering works offline and survives restarts.
+ *
+ * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
+ */
+import { useEffect, useState } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData, setReferenceData } from "./operations";
+import { businessService } from "../adapters/services";
+const MEMBERSHIP_KEYS = {
+    all: ["my-membership"],
+    byBusiness: (id) => [...MEMBERSHIP_KEYS.all, id],
+};
+function useCapabilitiesPlaceholder(businessId) {
+    const [cached, setCached] = useState(null);
+    useEffect(() => {
+        if (!businessId) {
+            setCached(null);
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const db = await openSyncDatabase();
+                const rec = await getReferenceData(db, businessId, "capabilities");
+                if (!cancelled && rec?.payload)
+                    setCached(rec.payload);
+            }
+            catch { }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [businessId]);
+    return cached;
+}
+/**
+ * Standard hook for both apps — businessId comes from the host's active business store.
+ * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ */
+export function useBusinessCapabilities(businessId) {
+    const queryClient = useQueryClient();
+    void queryClient;
+    const cached = useCapabilitiesPlaceholder(businessId ?? null);
+    return useQuery({
+        queryKey: MEMBERSHIP_KEYS.byBusiness(businessId ?? ""),
+        queryFn: async () => {
+            const res = (await businessService.fetchMyBusinessMembership(businessId));
+            try {
+                const db = await openSyncDatabase();
+                await setReferenceData(db, businessId, {
+                    key: "capabilities",
+                    version: `membership-${Date.now()}`,
+                    payload: res,
+                    downloadedAt: new Date().toISOString(),
+                });
+            }
+            catch { }
+            return res;
+        },
+        enabled: !!businessId,
+        staleTime: Infinity,
+        placeholderData: cached ?? undefined,
+        select: (data) => ({
+            role: data.data.role,
+            source: data.data.source,
+            capabilities: data.data.capabilities,
+            status: data.data.status,
+        }),
+    });
+}
+export function useHasCapabilityFor(businessId, capability) {
+    const { data } = useBusinessCapabilities(businessId);
+    return data?.capabilities.includes(capability) ?? false;
+}

package/dist/reference/service.js

@@ -23,6 +23,7 @@ const DEFAULT_SYNC_KEYS = [
     "business:profile",
     "operating-hours",
     "subscription:entitlements",
+    "capabilities",
 ];
 class ReferenceSyncService {
     constructor() {
@@ -204,6 +205,13 @@ class ReferenceSyncService {
                     version: this.hashPayload(response),
                 };
             }
+            case "capabilities": {
+                const response = await businessService.fetchMyBusinessMembership(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
             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";
+export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "subscription:entitlements" | "capabilities";
 export interface ReferenceDataRecord<T = unknown> {
     key: ReferenceDataKey;
     version: string;

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

@@ -10,6 +10,7 @@
  */
 import type { Command, DomainEvent, PersistedCommand } from "./types";
 import type { SyncEngine } from "./engine";
+export declare function getQueuedStatus(commandType: string): string | null;
 declare class CommandQueueService {
     private replaying;
     private syncEngine;

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

@@ -14,8 +14,34 @@ import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
 import { generateLocalOrderNumber, generateLocalCalloutNumber, } from "./order-number";
 const MAX_RETRIES = 5;
+const QUEUED_STATUS_BY_COMMAND = {
+    "order:accept": "accepted",
+    "order:reject": "cancelled",
+    "order:start_preparing": "preparing",
+    "order:mark_ready": "ready",
+    "order:complete_pickup": "delivered",
+    "order:cancel": "cancelled",
+    "delivery:assign": "assigned",
+    "delivery:confirm_handover": "delivered",
+};
+export function getQueuedStatus(commandType) {
+    return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
+}
 function buildOptimisticEvent(command) {
     const payload = command.payload;
+    if (command.command_type === "order:create") {
+        return {
+            event_id: generateEventId(),
+            event_type: `${command.command_type.replace(":", ".")}_queued`,
+            event_version: "1.0",
+            entity_id: command.entity_id ?? command.command_id,
+            user_id: command.user_id,
+            device_id: command.device_id,
+            payload: buildOptimisticOrder(command, payload),
+            timestamp: new Date().toISOString(),
+        };
+    }
+    const queuedStatus = getQueuedStatus(command.command_type);
     return {
         event_id: generateEventId(),
         event_type: `${command.command_type.replace(":", ".")}_queued`,
@@ -23,13 +49,15 @@ function buildOptimisticEvent(command) {
         entity_id: command.entity_id ?? command.command_id,
         user_id: command.user_id,
         device_id: command.device_id,
-        payload: command.command_type === "order:create"
-            ? buildOptimisticOrder(command, payload)
-            : {
-                ...payload,
-                command_id: command.command_id,
-                status: "pending",
-            },
+        payload: {
+            ...payload,
+            command_id: command.command_id,
+            status: "pending",
+            // Used by offline read-model patching so the list reflects the queued transition.
+            to_status: queuedStatus,
+            order_id: command.entity_id,
+            delivery_id: command.entity_id,
+        },
         timestamp: new Date().toISOString(),
     };
 }
@@ -136,17 +164,17 @@ class CommandQueueService {
             order_number: event.payload.order_number ?? null,
             status: event.payload.status,
         });
-        // Persist the optimistic order so it survives app restarts and can be
-        // rehydrated (and shown) while still offline.
-        if (preparedCommand.command_type === "order:create") {
-            try {
-                await insertEvent(db, { event, origin: "local" });
-            }
-            catch (error) {
-                syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
-                    error: String(error),
-                });
-            }
+        // Persist optimistic events so they survive restarts and can be
+        // rehydrated offline. For order:create this is the full order; for
+        // transitions it carries to_status so the read model can reflect the
+        // queued status immediately.
+        try {
+            await insertEvent(db, { event, origin: "local" });
+        }
+        catch (error) {
+            syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
+                error: String(error),
+            });
         }
         return event;
     }
@@ -188,6 +216,24 @@ class CommandQueueService {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            // Distinguish retryable (network/5xx/timeout) vs non-retryable (4xx validation)
+            // so a rejected order does not block the entire outbox.
+            const apiErr = error;
+            const isNonRetryable = apiErr?.name === "ApiError" &&
+                typeof apiErr.status === "number" &&
+                apiErr.status >= 400 &&
+                apiErr.status < 500;
+            if (isNonRetryable) {
+                await updateCommandStatus(db, command.command_id, "failed", `permanent:${message}`);
+                syncLogger.warn("CommandQueueService", "Queued command rejected by server (not retrying)", {
+                    command_id: command.command_id,
+                    command_type: command.command_type,
+                    status: apiErr.status,
+                    error: message,
+                });
+                // Do not throw — allow replay to continue to next command.
+                return;
+            }
             await updateCommandStatus(db, command.command_id, "failed", message);
             syncLogger.command(parsedCommand, "failed", { error: message });
             throw error;
@@ -218,8 +264,17 @@ class CommandQueueService {
                 try {
                     await this.processCommand(command);
                 }
-                catch {
-                    // Stop replay on first failure; retry will happen on next trigger.
+                catch (e) {
+                    const apiErr = e;
+                    const isNonRetryable = apiErr?.name === "ApiError" &&
+                        typeof apiErr.status === "number" &&
+                        apiErr.status >= 400 &&
+                        apiErr.status < 500;
+                    if (isNonRetryable) {
+                        // Already marked permanent in processCommand — continue to next.
+                        continue;
+                    }
+                    // Network/5xx — stop to preserve ordering; retry later.
                     break;
                 }
             }

package/dist/sync/order-snapshots.service.d.ts

@@ -22,6 +22,13 @@ declare class OrderSnapshotsService {
      * duplicates).
      */
     persistOrderEvent(event: DomainEvent, origin: "local" | "lan" | "cloud"): Promise<boolean>;
+    /**
+     * Patch the latest status for a queued transition (e.g. accept_queued)
+     * carrying to_status/order_id. Used so offline devices see the new status
+     * immediately and after restart via the durable snapshot.
+     */
+    applyQueuedStatusEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
+    private applyOrderStatusToReadModelInternal;
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.

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

@@ -50,17 +50,29 @@ class OrderSnapshotsService {
         }
     }
     /**
-     * Patch the latest status of a known order inside every list snapshot for the
-     * business, so offline devices see live status changes without a refetch.
+     * Patch the latest status for a queued transition (e.g. accept_queued)
+     * carrying to_status/order_id. Used so offline devices see the new status
+     * immediately and after restart via the durable snapshot.
      */
-    async applyOrderStatusToReadModel(db, event) {
+    async applyQueuedStatusEvent(event, origin = "local") {
         const payload = event.payload;
-        const orderId = payload?.order_id;
-        const toStatus = payload?.to_status ??
-            payload?.status;
-        if (!orderId || !toStatus || event.event_type !== "order.status_changed") {
+        const toStatus = payload?.to_status;
+        const orderId = payload?.order_id ?? event.entity_id;
+        if (!toStatus || !orderId)
             return;
+        try {
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            await this.applyOrderStatusToReadModelInternal(db, orderId, toStatus, event);
+        }
+        catch (error) {
+            syncLogger.error("OrderSnapshots", "Failed to apply queued status", {
+                error: String(error),
+                event_type: event.event_type,
+            });
         }
+    }
+    async applyOrderStatusToReadModelInternal(db, orderId, toStatus, event) {
         try {
             const lists = await getEntitySnapshotsByType(db, "seller_orders");
             for (const list of lists) {
@@ -85,6 +97,20 @@ class OrderSnapshotsService {
             });
         }
     }
+    /**
+     * Patch the latest status of a known order inside every list snapshot for the
+     * business, so offline devices see live status changes without a refetch.
+     */
+    async applyOrderStatusToReadModel(db, event) {
+        const payload = event.payload;
+        const orderId = payload?.order_id;
+        const toStatus = payload?.to_status ??
+            payload?.status;
+        if (!orderId || !toStatus || event.event_type !== "order.status_changed") {
+            return;
+        }
+        await this.applyOrderStatusToReadModelInternal(db, orderId, toStatus, event);
+    }
     /**
      * Write through a fetched order list so it is available offline. Used by the
      * seller and POS order queries. `scope` distinguishes complementary lists

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

@@ -26,6 +26,16 @@ const ORDER_STATE_EVENT_TYPES = new Set([
     "delivery.status_changed",
     "delivery.assigned",
 ]);
+const QUEUED_STATUS_EVENT_TYPES = new Set([
+    "order.accept_queued",
+    "order.reject_queued",
+    "order.start_preparing_queued",
+    "order.mark_ready_queued",
+    "order.complete_pickup_queued",
+    "order.cancel_queued",
+    "delivery.assign_queued",
+    "delivery.confirm_handover_queued",
+]);
 let invalidator = null;
 /**
  * Register a callback used to invalidate TanStack Query caches when a pending
@@ -88,7 +98,8 @@ export async function hydratePendingOrders() {
  */
 export async function applyOrderStateChangeEvent(event, origin = "local") {
     try {
-        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type))
+        const isQueued = QUEUED_STATUS_EVENT_TYPES.has(event.event_type);
+        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued)
             return;
         syncLogger.debug("OrderState", "Order state changed", {
             origin,
@@ -97,6 +108,12 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         });
         // Persist the event into the durable journal and patch the offline read
         // model so every terminal keeps the same order states after a restart.
+        // Queued transitions carry to_status/order_id so they patch instantly offline.
+        if (isQueued) {
+            await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            invalidator?.();
+            return;
+        }
         await orderSnapshotsService.persistOrderEvent(event, origin);
         invalidator?.();
     }
@@ -118,6 +135,14 @@ export async function applyPendingOrderEvent(event, origin = "local") {
             await insertEvent(db, { event, origin });
             return;
         }
+        if (QUEUED_STATUS_EVENT_TYPES.has(event.event_type)) {
+            // Queued transitions: patch the read model so listing reflects new status offline.
+            await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            invalidator?.();
+            return;
+        }
         if (event.event_type === "order.created") {
             const payload = event.payload;
             const localOrderNumber = payload?.local_order_number;

package/dist/utils/customer-display.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Customer display helpers — offline-first, shared by mobile + desktop.
+ * SellerOrder shape comes from backend order_serializer (customer_name, is_pos, user{full_name, avatar_url, phone}).
+ */
+import type { SellerOrder } from "../types/api/seller.api";
+export type CustomerDisplay = {
+    name: string;
+    avatarUrl: string | null;
+    phone: string | null;
+    isWalkIn: boolean;
+    tellerName?: string | null;
+};
+type OrderLike = Pick<SellerOrder, "customer_name"> & {
+    user?: {
+        full_name?: string;
+        avatar_url?: string;
+        phone?: string;
+    } | null;
+    customer_phone?: string | null;
+    is_pos?: boolean;
+};
+/**
+ * Single source of truth for customer identity.
+ * - is_pos:true (POS walk-in): customer is walk-in/typed name, never the staff user.
+ *   Staff is the teller (order.user) — do not show staff avatar as customer.
+ *   Returns tellerName so UI can optionally show "Teller: <name>" underneath.
+ * - is_pos:false (WhatsApp / online / AI agent): customer_name || user.full_name || "Customer" + avatar from user.avatar_url
+ */
+export declare function getCustomerDisplay(order: OrderLike): CustomerDisplay;
+export declare function getCustomerSearchKeys(order: OrderLike): string[];
+export declare function matchesCustomerSearch(order: OrderLike, qLower: string): boolean;
+export {};

package/dist/utils/customer-display.js

@@ -0,0 +1,55 @@
+/**
+ * Customer display helpers — offline-first, shared by mobile + desktop.
+ * SellerOrder shape comes from backend order_serializer (customer_name, is_pos, user{full_name, avatar_url, phone}).
+ */
+/**
+ * Single source of truth for customer identity.
+ * - is_pos:true (POS walk-in): customer is walk-in/typed name, never the staff user.
+ *   Staff is the teller (order.user) — do not show staff avatar as customer.
+ *   Returns tellerName so UI can optionally show "Teller: <name>" underneath.
+ * - is_pos:false (WhatsApp / online / AI agent): customer_name || user.full_name || "Customer" + avatar from user.avatar_url
+ */
+export function getCustomerDisplay(order) {
+    if (order.is_pos) {
+        const walkName = order.customer_name?.trim() ? order.customer_name.trim() : "Walk-in";
+        return {
+            name: walkName,
+            avatarUrl: null,
+            phone: order.customer_phone ?? null,
+            isWalkIn: true,
+            tellerName: order.user?.full_name?.trim() ?? null,
+        };
+    }
+    const rawName = order.customer_name?.trim()
+        ? order.customer_name.trim()
+        : order.user?.full_name?.trim() ?? "";
+    if (rawName) {
+        return {
+            name: rawName,
+            avatarUrl: order.user?.avatar_url ?? null,
+            phone: order.customer_phone ?? order.user?.phone ?? null,
+            isWalkIn: false,
+        };
+    }
+    return {
+        name: "Customer",
+        avatarUrl: order.user?.avatar_url ?? null,
+        phone: order.customer_phone ?? order.user?.phone ?? null,
+        isWalkIn: false,
+    };
+}
+export function getCustomerSearchKeys(order) {
+    return [
+        order.customer_name ?? "",
+        order.user?.full_name ?? "",
+        order.customer_phone ?? "",
+        order.user?.phone ?? "",
+        order.user?.avatar_url ?? "",
+    ];
+}
+export function matchesCustomerSearch(order, qLower) {
+    if (!qLower)
+        return true;
+    const hay = `${order.customer_name ?? ""} ${order.user?.full_name ?? ""} ${order.customer_phone ?? ""} ${order.user?.phone ?? ""}`.toLowerCase();
+    return hay.includes(qLower);
+}

package/dist/utils/order-filter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Offline order list helpers — shared filtering + pagination for
+ * usePOSOrdersQuery / useSellerOrdersQuery snapshot fallbacks.
+ */
+import type { SellerOrder } from "../types/api/seller.api";
+export declare function filterOrdersOffline(orders: SellerOrder[], filters?: {
+    status?: string;
+    order_type?: string;
+    is_pos?: string;
+    q?: string;
+    search?: string;
+}): SellerOrder[];
+export declare function filterSellerOrdersOffline(orders: SellerOrder[], filters?: {
+    status?: string;
+    q?: string;
+}): SellerOrder[];
+export declare function paginateOffline<T>(orders: T[], page: number, pageSize?: number): {
+    data: T[];
+    pagination: {
+        page: number;
+        page_size: number;
+        total_pages: number;
+        total_count: number;
+    };
+};

package/dist/utils/order-filter.js

@@ -0,0 +1,41 @@
+/**
+ * Offline order list helpers — shared filtering + pagination for
+ * usePOSOrdersQuery / useSellerOrdersQuery snapshot fallbacks.
+ */
+import { matchesCustomerSearch } from "./customer-display";
+export function filterOrdersOffline(orders, filters) {
+    let filtered = orders;
+    const statusSet = filters?.status ? new Set(filters.status.split(",").map((s) => s.trim())) : null;
+    if (statusSet)
+        filtered = filtered.filter((o) => statusSet.has(o.status));
+    if (filters?.order_type)
+        filtered = filtered.filter((o) => (o.order_type ?? "pos") === filters.order_type);
+    if (filters?.is_pos !== undefined) {
+        const wantPos = filters.is_pos === "true" || filters.is_pos === "1";
+        filtered = filtered.filter((o) => !!o.is_pos === wantPos);
+    }
+    const q = (filters?.q ?? filters?.search ?? "").toLowerCase();
+    if (q) {
+        filtered = filtered.filter((o) => o.order_number.toLowerCase().includes(q) ||
+            matchesCustomerSearch(o, q));
+    }
+    return filtered;
+}
+export function filterSellerOrdersOffline(orders, filters) {
+    let filtered = orders;
+    if (filters?.status) {
+        const set = new Set(filters.status.split(",").map((s) => s.trim()));
+        filtered = filtered.filter((o) => set.has(o.status));
+    }
+    if (filters?.q) {
+        const q = filters.q.toLowerCase();
+        filtered = filtered.filter((o) => o.order_number.toLowerCase().includes(q) || matchesCustomerSearch(o, q));
+    }
+    return filtered;
+}
+export function paginateOffline(orders, page, pageSize = 20) {
+    const start = (page - 1) * pageSize;
+    const slice = orders.slice(start, start + pageSize);
+    const totalPages = Math.max(1, Math.ceil(orders.length / pageSize));
+    return { data: slice, pagination: { page, page_size: pageSize, total_pages: totalPages, total_count: orders.length } };
+}

package/package.json

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