@teincfood/core 0.7.4 → 0.7.5

package/dist/adapters/business.d.ts

@@ -1,13 +1,20 @@
 /**
- * Business store stub.
+ * Business store adapter — host app injects active business; core hooks subscribe.
  */
 export declare function setActiveBusiness(b: {
     id: string;
 } | null): void;
+export declare function getActiveBusiness(): {
+    id: string;
+} | null;
+export declare function subscribeBusiness(listener: (b: {
+    id: string;
+} | null) => void): () => void;
 export declare const useBusinessStore: {
     getState: () => {
         activeBusiness: {
             id: string;
         } | null;
     };
+    subscribe: typeof subscribeBusiness;
 };

package/dist/adapters/business.js

@@ -1,10 +1,20 @@
 /**
- * Business store stub.
+ * Business store adapter — host app injects active business; core hooks subscribe.
  */
 let activeBusiness = null;
+const listeners = new Set();
 export function setActiveBusiness(b) {
     activeBusiness = b;
+    listeners.forEach((l) => l(b));
+}
+export function getActiveBusiness() {
+    return activeBusiness;
+}
+export function subscribeBusiness(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
 }
 export const useBusinessStore = {
     getState: () => ({ activeBusiness }),
+    subscribe: subscribeBusiness,
 };

package/dist/adapters/pending-orders.d.ts

@@ -1,17 +1,26 @@
 /**
- * Pending orders store stub.
+ * Pending orders store — holds locally queued (offline) order:create commands
+ * as optimistic SellerOrders so they remain visible on every terminal until
+ * the cloud acknowledges them. Observable so React hooks can subscribe.
  */
 import type { SellerOrder } from "../types/api/seller.api";
+export declare function subscribePendingOrders(listener: () => void): () => void;
+export declare function getPendingOrdersSnapshot(): {
+    orders: SellerOrder[];
+    hydrated: boolean;
+};
 export declare const usePendingOrdersStore: {
     getState: () => {
         hydrated: boolean;
         orders: SellerOrder[];
         addOrder: (order: SellerOrder) => void;
         removeByOrderNumber: (orderNumber: string) => void;
+        removeByOrderId: (orderId: string) => void;
         setHydrated: (v: boolean) => void;
     };
     setState: (patch: Partial<{
         orders: SellerOrder[];
         hydrated: boolean;
     }>) => void;
+    subscribe: typeof subscribePendingOrders;
 };

package/dist/adapters/pending-orders.js

@@ -1,28 +1,64 @@
 /**
- * Pending orders store stub.
+ * Pending orders store — holds locally queued (offline) order:create commands
+ * as optimistic SellerOrders so they remain visible on every terminal until
+ * the cloud acknowledges them. Observable so React hooks can subscribe.
  */
 let orders = [];
 let hydrated = false;
+const listeners = new Set();
+function notify() {
+    listeners.forEach((l) => l());
+}
+export function subscribePendingOrders(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function getPendingOrdersSnapshot() {
+    return { orders: [...orders], hydrated };
+}
 export const usePendingOrdersStore = {
     getState: () => ({
         hydrated,
-        orders,
+        orders: [...orders],
         addOrder: (order) => {
             if (!orders.find((o) => o.order_number === order.order_number)) {
-                orders.push(order);
+                orders = [...orders, order];
+                notify();
             }
         },
         removeByOrderNumber: (orderNumber) => {
-            orders = orders.filter((o) => o.order_number !== orderNumber);
+            const next = orders.filter((o) => o.order_number !== orderNumber);
+            if (next.length !== orders.length) {
+                orders = next;
+                notify();
+            }
+        },
+        removeByOrderId: (orderId) => {
+            const next = orders.filter((o) => o.id !== orderId);
+            if (next.length !== orders.length) {
+                orders = next;
+                notify();
+            }
         },
         setHydrated: (v) => {
-            hydrated = v;
+            if (hydrated !== v) {
+                hydrated = v;
+                notify();
+            }
         },
     }),
     setState: (patch) => {
-        if (patch.orders !== undefined)
-            orders = patch.orders;
-        if (patch.hydrated !== undefined)
+        let changed = false;
+        if (patch.orders !== undefined) {
+            orders = [...patch.orders];
+            changed = true;
+        }
+        if (patch.hydrated !== undefined && hydrated !== patch.hydrated) {
             hydrated = patch.hydrated;
+            changed = true;
+        }
+        if (changed)
+            notify();
     },
+    subscribe: subscribePendingOrders,
 };

package/dist/adapters/services.d.ts

@@ -10,6 +10,17 @@ export declare const posService: {
     fetchBusinessOrders: (_businessId: string, _params?: unknown) => Promise<unknown>;
 };
 export declare const sellerService: {
+    fetchBusinessOrders: (_businessId: string, _params?: Record<string, unknown>) => Promise<{
+        data: unknown[];
+        pagination: unknown;
+    }>;
+    fetchSellerOrder: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    fetchBusinessDeliveries: (_businessId: string, _params?: Record<string, unknown>) => Promise<{
+        data: unknown[];
+        pagination: unknown;
+    }>;
     acceptOrder: (_orderId: string) => Promise<{
         data: unknown;
     }>;

package/dist/adapters/services.js

@@ -17,8 +17,17 @@ export const posService = {
         notImpl("posService.fetchBusinessOrders");
     },
 };
-// seller.service
+// seller.service — also order listing used by POS/seller order lifecycle
 export const sellerService = {
+    fetchBusinessOrders: async (_businessId, _params) => {
+        notImpl("sellerService.fetchBusinessOrders");
+    },
+    fetchSellerOrder: async (_orderId) => {
+        notImpl("sellerService.fetchSellerOrder");
+    },
+    fetchBusinessDeliveries: async (_businessId, _params) => {
+        notImpl("sellerService.fetchBusinessDeliveries");
+    },
     acceptOrder: async (_orderId) => {
         notImpl("sellerService.acceptOrder");
     },

package/dist/hooks/orders.hooks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Order lifecycle hooks — offline-first, device-owned outbox.
+ *
+ * Device owns its partition: when offline it serves the durable
+ * entity_snapshots + pending overlay immediately; the SyncEngine replays
+ * queued commands when back online. No hook ever blocks on a cloud timeout
+ * when offline.
+ *
+ * Host apps just re-export from "@teincfood/core" — no app-local duplication.
+ */
+import type { POSOrderCreateRequest, POSOrderPreviewResponse } from "../types/pos.types";
+import type { POSCartItem, POSOrderType } from "../types/pos.types";
+import type { SellerOrder } from "../types/api/seller.api";
+export declare const POS_KEYS: {
+    readonly all: readonly ["pos"];
+    readonly orders: (businessId?: string) => readonly ["pos", "orders", string | undefined];
+    readonly preview: (businessId?: string) => readonly ["pos", "preview", string | undefined];
+};
+export declare const SELLER_KEYS: {
+    readonly all: readonly ["seller"];
+    readonly orders: (businessId?: string, filters?: Record<string, unknown>) => readonly unknown[];
+    readonly deliveries: (businessId?: string, filters?: Record<string, unknown>) => readonly unknown[];
+    readonly order: (id: string, businessId?: string) => readonly ["seller", "order", string, string | undefined];
+};
+export declare function usePOSOrdersQuery(filters?: {
+    status?: string;
+    order_type?: string;
+    is_pos?: string;
+    date_from?: string;
+    date_to?: string;
+    q?: string;
+    search?: string;
+}, enabled?: boolean): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error> & {
+    data: SellerOrder[] | undefined;
+};
+export declare function useSellerOrdersQuery(enabled?: boolean, filters?: {
+    status?: string;
+    q?: string;
+    search?: string;
+    date_from?: string;
+    date_to?: string;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error> & {
+    data: SellerOrder[] | undefined;
+};
+export declare function usePendingOrders(businessId?: string): SellerOrder[];
+export declare function useCreatePOSOrderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, POSOrderCreateRequest, unknown>;
+export declare function usePOSOrderPreviewQuery(items: POSCartItem[], orderType: POSOrderType, customerName: string): import("@tanstack/react-query").UseQueryResult<POSOrderPreviewResponse, Error>;
+export declare const useAcceptOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useRejectOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useStartPreparingOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useMarkOrderReadyMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useCompletePickupMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useCancelOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;

package/dist/hooks/orders.hooks.js

@@ -0,0 +1,300 @@
+/**
+ * Order lifecycle hooks — offline-first, device-owned outbox.
+ *
+ * Device owns its partition: when offline it serves the durable
+ * entity_snapshots + pending overlay immediately; the SyncEngine replays
+ * queued commands when back online. No hook ever blocks on a cloud timeout
+ * when offline.
+ *
+ * Host apps just re-export from "@teincfood/core" — no app-local duplication.
+ */
+import { useEffect, useMemo, useSyncExternalStore } from "react";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { posRepository } from "../repositories/pos.repository";
+import { orderRepository } from "../repositories/order.repository";
+import { sellerService } from "../adapters/services";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+import { getPendingOrdersSnapshot, subscribePendingOrders, } from "../adapters/pending-orders";
+import { orderSnapshotsService } from "../sync/order-snapshots.service";
+import { hydratePendingOrders } from "../sync/pending-orders.service";
+import { isLocalOrderNumber } from "../sync/order-number";
+import { filterOrdersOffline, paginateOffline } from "../utils/order-filter";
+// ─── Keys (host apps should import from core, not define their own) ─────
+export const POS_KEYS = {
+    all: ["pos"],
+    orders: (businessId) => ["pos", "orders", businessId],
+    preview: (businessId) => ["pos", "preview", businessId],
+};
+export const SELLER_KEYS = {
+    all: ["seller"],
+    orders: (businessId, filters) => [...SELLER_KEYS.all, "orders", businessId, filters].filter((x) => x !== undefined),
+    deliveries: (businessId, filters) => [...SELLER_KEYS.all, "deliveries", businessId, filters].filter((x) => x !== undefined),
+    order: (id, businessId) => [...SELLER_KEYS.all, "order", id, businessId],
+};
+// ─── Helpers ───────────────────────────────────────────────────────────────
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+function useConnectivity() {
+    const state = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    return state;
+}
+function useCorePendingOrders(businessId) {
+    const snap = useSyncExternalStore(subscribePendingOrders, getPendingOrdersSnapshot, getPendingOrdersSnapshot);
+    useEffect(() => {
+        if (snap.hydrated)
+            return;
+        hydratePendingOrders().catch(() => { });
+    }, [snap.hydrated]);
+    return useMemo(() => (businessId ? snap.orders.filter((o) => o.business_id === businessId) : snap.orders), [snap.orders, businessId]);
+}
+function mergePendingOrders(pending, serverOrders) {
+    if (pending.length === 0)
+        return serverOrders ?? [];
+    const seen = new Set();
+    const merged = [];
+    for (const order of pending) {
+        seen.add(order.order_number);
+        merged.push(order);
+    }
+    for (const order of serverOrders ?? []) {
+        if (!seen.has(order.order_number))
+            merged.push(order);
+    }
+    return merged.sort((a, b) => (b.inserted_at ?? "").localeCompare(a.inserted_at ?? ""));
+}
+function isOfflineState(s) {
+    return !s.isOnline || s.isCloudReachable === "unreachable";
+}
+// ─── POS Orders Query (offline-first) ─────────────────────────────────────
+export function usePOSOrdersQuery(filters, enabled = true) {
+    const businessId = useBusinessId();
+    const pendingOrders = useCorePendingOrders(businessId);
+    const connectivity = useConnectivity();
+    const offline = isOfflineState(connectivity);
+    const query = useInfiniteQuery({
+        queryKey: [...POS_KEYS.orders(businessId), filters],
+        queryFn: async ({ pageParam = 1 }) => {
+            const params = { page: String(pageParam) };
+            if (filters?.status)
+                params.status = filters.status;
+            if (filters?.order_type)
+                params.order_type = filters.order_type;
+            if (filters?.is_pos)
+                params.is_pos = filters.is_pos;
+            if (filters?.date_from)
+                params.date_from = filters.date_from;
+            if (filters?.date_to)
+                params.date_to = filters.date_to;
+            if (filters?.q)
+                params.q = filters.q;
+            if (filters?.search)
+                params.search = filters.search;
+            if (offline) {
+                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const base = offlineList ?? [];
+                const filtered = filterOrdersOffline(base, filters);
+                // date_from/to are handled inside filterSellerOrders via inserted_at; apply if present
+                const paged = paginateOffline(filtered, pageParam, 20);
+                return paged;
+            }
+            try {
+                const result = (await posRepository.fetchOrders(businessId, params));
+                if (pageParam === 1 && businessId && Array.isArray(result.data)) {
+                    orderSnapshotsService.persistSellerOrders(businessId, businessId, result.data).catch(() => { });
+                }
+                return result;
+            }
+            catch (e) {
+                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                if (offlineList) {
+                    const filtered = filterOrdersOffline(offlineList, filters);
+                    const paged = paginateOffline(filtered, pageParam, 20);
+                    return paged;
+                }
+                throw e;
+            }
+        },
+        initialPageParam: 1,
+        getNextPageParam: (lastPage) => {
+            const p = lastPage.pagination;
+            return p && p.page < p.total_pages ? p.page + 1 : undefined;
+        },
+        enabled: enabled && !!businessId,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+        select: (data) => data.pages.flatMap((p) => p.data),
+    });
+    const data = useMemo(() => mergePendingOrders(pendingOrders, query.data), [pendingOrders, query.data]);
+    return { ...query, data };
+}
+// ─── Seller Orders Query (offline-first, shares same snapshot) ────────────
+export function useSellerOrdersQuery(enabled = true, filters) {
+    const businessId = useBusinessId();
+    const pendingOrders = useCorePendingOrders(businessId);
+    const connectivity = useConnectivity();
+    const offline = isOfflineState(connectivity);
+    const query = useInfiniteQuery({
+        queryKey: SELLER_KEYS.orders(businessId, filters),
+        queryFn: async ({ pageParam = 1 }) => {
+            const params = { page: pageParam, page_size: 20 };
+            if (filters?.status)
+                params.status = filters.status;
+            if (filters?.q)
+                params.q = filters.q;
+            if (filters?.search)
+                params.search = filters.search;
+            if (filters?.date_from)
+                params.date_from = filters.date_from;
+            if (filters?.date_to)
+                params.date_to = filters.date_to;
+            if (offline) {
+                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const base = offlineList ?? [];
+                const filtered = filterOrdersOffline(base, filters);
+                const paged = paginateOffline(filtered, pageParam, 20);
+                return paged;
+            }
+            try {
+                const result = (await sellerService.fetchBusinessOrders(businessId, params));
+                if (pageParam === 1 && businessId && Array.isArray(result.data)) {
+                    orderSnapshotsService.persistSellerOrders(businessId, businessId, result.data).catch(() => { });
+                }
+                return result;
+            }
+            catch (e) {
+                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                if (offlineList) {
+                    const filtered = filterOrdersOffline(offlineList, filters);
+                    const paged = paginateOffline(filtered, pageParam, 20);
+                    return paged;
+                }
+                throw e;
+            }
+        },
+        initialPageParam: 1,
+        getNextPageParam: (lastPage) => {
+            const p = lastPage.pagination;
+            return p && p.page < p.total_pages ? p.page + 1 : undefined;
+        },
+        enabled: enabled && !!businessId,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+        select: (data) => data.pages.flatMap((p) => p.data),
+    });
+    const data = useMemo(() => mergePendingOrders(pendingOrders, query.data), [pendingOrders, query.data]);
+    return { ...query, data };
+}
+// ─── Pending orders hook (for screens that just need the overlay) ─────────
+export function usePendingOrders(businessId) {
+    return useCorePendingOrders(businessId);
+}
+// ─── Create POS Order (device-lease aware, via SyncEngine) ────────────────
+export function useCreatePOSOrderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const { isOnline, isCloudReachable } = getConnectivityState();
+            if (!businessId)
+                throw new Error("Missing business — select a business before creating orders");
+            try {
+                const m = await import("../sync/device-lease.service");
+                const dn = m.getDeviceNumber?.(businessId) ?? null;
+                if (!dn) {
+                    const leased = await m.ensureDeviceLease?.(businessId);
+                    if (!leased && (!isOnline || isCloudReachable === "unreachable")) {
+                        throw new Error("No device number leased (99 devices max) — cannot create offline orders");
+                    }
+                }
+            }
+            catch (e) {
+                if (e?.message?.includes("device number") || e?.message?.includes("No device lease"))
+                    throw e;
+            }
+            return posRepository.createOrder(businessId, data);
+        },
+        onSuccess: (result) => {
+            const r = result;
+            const orderNumber = r?.order_number ?? "";
+            const queued = orderNumber ? isLocalOrderNumber(orderNumber) && r?.status === "pending" : false;
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.orders(businessId) });
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            // Toast is host concern — core just invalidates; host can show queued vs created.
+            void queued;
+        },
+    });
+}
+// ─── Preview (offline via tax-rules reference) ────────────────────────────
+function cartHash(items) {
+    if (items.length === 0)
+        return "";
+    return items
+        .map((i) => `${i.menu_item.id}:${i.quantity}:${i.selected_variant?.id || ""}:${(i.selected_addons || []).map((a) => a.addon_id).sort().join(",")}`)
+        .join("|");
+}
+export function usePOSOrderPreviewQuery(items, orderType, customerName) {
+    const businessId = useBusinessId();
+    const hash = useMemo(() => cartHash(items), [items]);
+    return useQuery({
+        queryKey: [...POS_KEYS.preview(businessId), hash, orderType, customerName],
+        queryFn: async () => {
+            const orderItems = items.map((i) => ({
+                menu_item_id: i.menu_item.id,
+                quantity: i.quantity,
+                variant_id: i.selected_variant?.id,
+                addon_ids: i.selected_addons.length > 0 ? i.selected_addons.map((a) => a.addon_id) : undefined,
+            }));
+            try {
+                return await posRepository.fetchPreview({ businessId: businessId, items: orderItems, orderType, customerName: customerName || undefined });
+            }
+            catch (e) {
+                const s = getConnectivityState();
+                const isOffline = !s.isOnline || s.isCloudReachable === "unreachable";
+                if (!isOffline)
+                    throw e;
+                const { openSyncDatabase } = await import("../db/connection");
+                const { getReferenceData } = await import("../reference/operations");
+                const { calculatePricing } = await import("../pricing/engine");
+                const db = await openSyncDatabase();
+                const taxRec = await getReferenceData(db, businessId, "tax-rules");
+                const taxRules = taxRec?.payload?.data ?? [];
+                const pricing = calculatePricing({ items: items, taxRules: taxRules });
+                return { data: { subtotal_minor: pricing.subtotal_minor, discount_minor: pricing.discount_minor, delivery_fee_minor: pricing.delivery_fee_minor, tax_minor: pricing.tax_minor, tip_minor: pricing.tip_minor, total_minor: pricing.total_minor, tax_lines: pricing.tax_lines, currency: pricing.currency_code } };
+            }
+        },
+        enabled: !!businessId && items.length > 0,
+        staleTime: 30 * 1000,
+    });
+}
+// ─── Order status mutations via SyncEngine (all go through outbox) ────────
+function makeOrderActionMutation(build) {
+    return function useOrderActionMutation() {
+        const businessId = useBusinessId();
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: (orderId) => {
+                if (!businessId)
+                    throw new Error("No active business");
+                return build({ orderId, businessId });
+            },
+            onSettled: (_d, _e, orderId) => {
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.orders() });
+                queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
+                if (orderId)
+                    queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) });
+            },
+        });
+    };
+}
+export const useAcceptOrderMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.acceptOrder({ orderId, businessId }));
+export const useRejectOrderMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.rejectOrder({ orderId, businessId }));
+export const useStartPreparingOrderMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.startPreparingOrder({ orderId, businessId }));
+export const useMarkOrderReadyMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.markOrderReady({ orderId, businessId }));
+export const useCompletePickupMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.completePickup({ orderId, businessId }));
+export const useCancelOrderMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.cancelOrder({ orderId, businessId }));

package/dist/index.d.ts

@@ -52,6 +52,7 @@ export { orderRepository } from "./repositories/order.repository";
 export type { CreateOrderInput, AssignRiderInput, OrderActionInput } from "./repositories/order.repository";
 export { posRepository } from "./repositories/pos.repository";
 export type { POSOrderPreviewInput } from "./repositories/pos.repository";
+export * from "./hooks/orders.hooks";
 export * from "./reference/types";
 export * from "./reference/operations";
 export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher } from "./reference/api";
@@ -69,6 +70,9 @@ export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
 export * from "./adapters/image-cache";
+export * from "./adapters/business";
+export * from "./adapters/pending-orders";
+export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
 import { type SqliteDriver } from "./adapters/sqlite";
 import { type KVDriver } from "./adapters/kv";
 import { type HttpClient } from "./adapters/http";

package/dist/index.js

@@ -53,6 +53,8 @@ export { runOfflineCapableMutation } from "./sync/offline-capable";
 // ── Repositories ──
 export { orderRepository } from "./repositories/order.repository";
 export { posRepository } from "./repositories/pos.repository";
+// ── Order lifecycle hooks (offline-first, device-owned outbox) ──
+export * from "./hooks/orders.hooks";
 // ── Reference ──
 export * from "./reference/types";
 export * from "./reference/operations";
@@ -71,6 +73,10 @@ export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
 export * from "./adapters/image-cache";
+export * from "./adapters/business";
+export * from "./adapters/pending-orders";
+export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
+// POS_KEYS / SELLER_KEYS are exported from hooks/orders.hooks (offline-first source of truth)
 // ── Init helper ──
 import { setSqliteDriver } from "./adapters/sqlite";
 import { setKVDriver } from "./adapters/kv";

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

@@ -9,6 +9,8 @@ export declare function filterOrdersOffline(orders: SellerOrder[], filters?: {
     is_pos?: string;
     q?: string;
     search?: string;
+    date_from?: string;
+    date_to?: string;
 }): SellerOrder[];
 export declare function filterSellerOrdersOffline(orders: SellerOrder[], filters?: {
     status?: string;

package/dist/utils/order-filter.js

@@ -19,6 +19,14 @@ export function filterOrdersOffline(orders, filters) {
         filtered = filtered.filter((o) => o.order_number.toLowerCase().includes(q) ||
             matchesCustomerSearch(o, q));
     }
+    if (filters?.date_from) {
+        const from = filters.date_from.slice(0, 10);
+        filtered = filtered.filter((o) => (o.inserted_at ?? "").slice(0, 10) >= from);
+    }
+    if (filters?.date_to) {
+        const to = filters.date_to.slice(0, 10);
+        filtered = filtered.filter((o) => (o.inserted_at ?? "").slice(0, 10) <= to);
+    }
     return filtered;
 }
 export function filterSellerOrdersOffline(orders, filters) {

package/package.json

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