@teincfood/core 0.7.7 → 0.7.8

package/dist/adapters/filesystem.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Filesystem adapter — host injects expo-file-system / Tauri fs
+ */
+export interface FileSystemAdapter {
+    getInfoAsync(path: string): Promise<{
+        exists: boolean;
+        isDirectory?: boolean;
+    }>;
+    makeDirectoryAsync(path: string, opts?: {
+        intermediates?: boolean;
+    }): Promise<void>;
+    downloadAsync(url: string, fileUri: string): Promise<{
+        uri: string;
+    }>;
+    deleteAsync(path: string, opts?: {
+        idempotent?: boolean;
+    }): Promise<void>;
+    readDirectoryAsync(path: string): Promise<string[]>;
+    getDocumentDirectory(): string;
+}
+export declare function setFileSystemAdapter(a: FileSystemAdapter | null): void;
+export declare function getFileSystemAdapter(): FileSystemAdapter | null;

package/dist/adapters/filesystem.js

@@ -0,0 +1,6 @@
+/**
+ * Filesystem adapter — host injects expo-file-system / Tauri fs
+ */
+let fsAdapter = null;
+export function setFileSystemAdapter(a) { fsAdapter = a; }
+export function getFileSystemAdapter() { return fsAdapter; }

package/dist/adapters/print.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Print adapters — host injects platform-specific implementations.
+ */
+export interface TcpSocketAdapter {
+    sendToTcpPrinter(ip: string, port: number, text: string): Promise<void>;
+}
+export interface PrintFileAdapter {
+    printToFileAsync(html: string): Promise<{
+        uri: string;
+    }>;
+    isSharingAvailable?(): Promise<boolean>;
+    shareAsync?(uri: string, options?: {
+        dialogTitle?: string;
+        mimeType?: string;
+    }): Promise<void>;
+}
+export interface MdnsAdapter {
+    discoverPrinters?(timeoutMs?: number): Promise<{
+        name: string;
+        ip: string;
+        port: number;
+    }[]>;
+}
+export declare function setTcpAdapter(a: TcpSocketAdapter | null): void;
+export declare function getTcpAdapter(): TcpSocketAdapter | null;
+export declare function setPrintFileAdapter(a: PrintFileAdapter | null): void;
+export declare function getPrintFileAdapter(): PrintFileAdapter | null;
+export declare function setMdnsAdapter(a: MdnsAdapter | null): void;
+export declare function getMdnsAdapter(): MdnsAdapter | null;

package/dist/adapters/print.js

@@ -0,0 +1,12 @@
+/**
+ * Print adapters — host injects platform-specific implementations.
+ */
+let tcpAdapter = null;
+let printFileAdapter = null;
+let mdnsAdapter = null;
+export function setTcpAdapter(a) { tcpAdapter = a; }
+export function getTcpAdapter() { return tcpAdapter; }
+export function setPrintFileAdapter(a) { printFileAdapter = a; }
+export function getPrintFileAdapter() { return printFileAdapter; }
+export function setMdnsAdapter(a) { mdnsAdapter = a; }
+export function getMdnsAdapter() { return mdnsAdapter; }

package/dist/cart/hooks.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Cart hooks — UI bindings for the device-local cart store + pricing.
+ */
+import { removeItem, updateQuantity, clearCart, clearAll } from "./store";
+import type { MenuItem, MenuItemVariantResponse, MenuItemAddonResponse } from "../types/api/menu.api";
+import type { POSCheckoutForm } from "../types/pos.types";
+export declare function usePOSStore(): {
+    items: import("..").POSCartItem[];
+    checkoutForm: POSCheckoutForm;
+    addItem: (menuItem: MenuItem, quantity: number, variant: MenuItemVariantResponse | null, addons: MenuItemAddonResponse[]) => void;
+    removeItem: typeof removeItem;
+    updateQuantity: typeof updateQuantity;
+    updateCheckoutForm: (u: Partial<POSCheckoutForm>) => void;
+    clearCart: typeof clearCart;
+    clearAll: typeof clearAll;
+};
+export declare function usePOSCart(): {
+    items: import("..").POSCartItem[];
+    checkoutForm: POSCheckoutForm;
+    addItem: (menuItem: MenuItem, quantity: number, variant: MenuItemVariantResponse | null, addons: MenuItemAddonResponse[]) => void;
+    removeItem: typeof removeItem;
+    updateQuantity: typeof updateQuantity;
+    updateCheckoutForm: (u: Partial<POSCheckoutForm>) => void;
+    clearCart: typeof clearCart;
+    clearAll: typeof clearAll;
+};
+/**
+ * Pricing hook — returns local calculation (always available offline) and
+ * optional cloud preview; mirrors CheckoutPanel calculatePricing logic.
+ */
+export declare function usePOSPricing(): {
+    cart: import("./store").CartState;
+    localPricing: import("..").PricingResult | null;
+    preview: import("@tanstack/react-query").UseQueryResult<import("..").POSOrderPreviewResponse, Error>;
+    currency: string;
+};

package/dist/cart/hooks.js

@@ -0,0 +1,45 @@
+/**
+ * Cart hooks — UI bindings for the device-local cart store + pricing.
+ */
+import { useEffect, useMemo, useSyncExternalStore } from "react";
+import { getCartSnapshot, subscribeCart, hydrateCartStore, addItem, removeItem, updateQuantity, updateCheckoutForm, clearCart, clearAll } from "./store";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { usePOSOrderPreviewQuery } from "../hooks/orders.hooks";
+import { calculatePricing } from "../pricing/engine";
+export function usePOSStore() {
+    const state = useSyncExternalStore(subscribeCart, getCartSnapshot, getCartSnapshot);
+    useEffect(() => { void hydrateCartStore(); }, []);
+    return {
+        items: state.items,
+        checkoutForm: state.checkoutForm,
+        addItem: (menuItem, quantity, variant, addons) => addItem(menuItem, quantity, variant, addons),
+        removeItem,
+        updateQuantity,
+        updateCheckoutForm: (u) => updateCheckoutForm(u),
+        clearCart,
+        clearAll,
+    };
+}
+export function usePOSCart() { return usePOSStore(); }
+/**
+ * Pricing hook — returns local calculation (always available offline) and
+ * optional cloud preview; mirrors CheckoutPanel calculatePricing logic.
+ */
+export function usePOSPricing() {
+    const cart = useSyncExternalStore(subscribeCart, getCartSnapshot, getCartSnapshot);
+    const business = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness(), () => null);
+    const currency = business?.currency_code ?? "GHS";
+    // Need tax rules — pull from reference_data via lazy import to avoid cycle
+    // For now, calculate without taxRules; host can pass taxRules if needed.
+    const localPricing = useMemo(() => {
+        try {
+            return calculatePricing({ items: cart.items, taxRules: [], currency_code: currency });
+        }
+        catch {
+            return null;
+        }
+    }, [cart.items, currency]);
+    // Cloud preview still available via dedicated hook
+    const preview = usePOSOrderPreviewQuery(cart.items, cart.checkoutForm.order_type, cart.checkoutForm.customer_name);
+    return { cart, localPricing, preview, currency };
+}

package/dist/cart/store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * POS cart store — device-local, persisted via KV driver.
+ * Mirrors TeincFoodBusiness/src/stores/pos.store.ts
+ * Persist key: "Teinc Food-pos-cart" (for migration compatibility).
+ */
+import type { MenuItem, MenuItemVariantResponse, MenuItemAddonResponse } from "../types/api/menu.api";
+import type { POSCartItem, POSCheckoutForm } from "../types/pos.types";
+export interface CartState {
+    items: POSCartItem[];
+    checkoutForm: POSCheckoutForm;
+}
+export declare function hydrateCartStore(): Promise<void>;
+export declare function getCartState(): CartState;
+export declare function subscribeCart(listener: () => void): () => void;
+export declare function getCartSnapshot(): CartState;
+export declare function addItem(menuItem: MenuItem, quantity: number, variant: MenuItemVariantResponse | null, addons: MenuItemAddonResponse[]): void;
+export declare function removeItem(cartItemId: string): void;
+export declare function updateQuantity(cartItemId: string, quantity: number): void;
+export declare function updateCheckoutForm(updates: Partial<POSCheckoutForm>): void;
+export declare function clearCart(): void;
+export declare function clearAll(): void;
+export declare const cartStore: {
+    getState: typeof getCartState;
+    subscribe: typeof subscribeCart;
+    getSnapshot: typeof getCartSnapshot;
+    hydrate: typeof hydrateCartStore;
+    addItem: typeof addItem;
+    removeItem: typeof removeItem;
+    updateQuantity: typeof updateQuantity;
+    updateCheckoutForm: typeof updateCheckoutForm;
+    clearCart: typeof clearCart;
+    clearAll: typeof clearAll;
+};

package/dist/cart/store.js

@@ -0,0 +1,122 @@
+/**
+ * POS cart store — device-local, persisted via KV driver.
+ * Mirrors TeincFoodBusiness/src/stores/pos.store.ts
+ * Persist key: "Teinc Food-pos-cart" (for migration compatibility).
+ */
+import { getKVDriver } from "../adapters/kv";
+const CART_KEY = "Teinc Food-pos-cart";
+const defaultCheckoutForm = {
+    customer_name: "",
+    customer_phone: "",
+    order_type: "takeout",
+    pos_payment_method: "cash",
+};
+let state = {
+    items: [],
+    checkoutForm: { ...defaultCheckoutForm },
+};
+let hydrated = false;
+const listeners = new Set();
+function notify() { listeners.forEach((l) => l()); }
+async function persist() {
+    try {
+        const kv = getKVDriver();
+        await kv.setItem(CART_KEY, JSON.stringify({ state: { items: state.items, checkoutForm: state.checkoutForm }, version: 0 }));
+    }
+    catch { }
+}
+export async function hydrateCartStore() {
+    if (hydrated)
+        return;
+    hydrated = true;
+    try {
+        const kv = getKVDriver();
+        const raw = await kv.getItem(CART_KEY);
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            const s = parsed.state ?? parsed;
+            state = {
+                items: Array.isArray(s.items) ? s.items : [],
+                checkoutForm: s.checkoutForm ? { ...defaultCheckoutForm, ...s.checkoutForm } : { ...defaultCheckoutForm },
+            };
+            notify();
+        }
+    }
+    catch { }
+}
+export function getCartState() { return state; }
+export function subscribeCart(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function getCartSnapshot() { return state; }
+function computeUnitPrice(menuItem, variant, addons) {
+    let price = menuItem?.basePrice?.amountMinor
+        ?? menuItem?.base_price?.amount_minor
+        ?? 0;
+    if (variant)
+        price = variant.price?.amountMinor ?? variant.price_minor ?? price;
+    // addons: amountMinor
+    for (const a of addons) {
+        const amt = a.amountMinor ?? a.amount_minor ?? 0;
+        price += amt;
+    }
+    return price;
+}
+function makeCartItemId(menuItemId, variantId, addonIds) {
+    const sorted = [...addonIds].sort();
+    return `${menuItemId}-${variantId || ""}-${sorted.join(",")}`;
+}
+export function addItem(menuItem, quantity, variant, addons) {
+    const variantId = variant?.id;
+    const addonIds = addons.map((a) => a.id);
+    const cartItemId = makeCartItemId(menuItem.id, variantId, addonIds);
+    const unitPrice = computeUnitPrice(menuItem, variant, addons);
+    const selectedAddons = addons.map((a) => ({
+        addon_id: a.id,
+        name: a.name,
+        price_minor: a.amountMinor ?? a.amount_minor ?? 0,
+    }));
+    const existing = state.items.find((i) => i.id === cartItemId);
+    if (existing) {
+        state = { ...state, items: state.items.map((i) => i.id === cartItemId ? { ...i, quantity: i.quantity + quantity } : i) };
+    }
+    else {
+        const item = {
+            id: cartItemId,
+            menu_item: menuItem,
+            quantity,
+            selected_variant: variant,
+            selected_addons: selectedAddons,
+            notes: "",
+            unit_price_minor: unitPrice,
+        };
+        state = { ...state, items: [...state.items, item] };
+    }
+    notify();
+    void persist();
+}
+export function removeItem(cartItemId) {
+    state = { ...state, items: state.items.filter((i) => i.id !== cartItemId) };
+    notify();
+    void persist();
+}
+export function updateQuantity(cartItemId, quantity) {
+    state = { ...state, items: state.items.map((i) => i.id === cartItemId ? { ...i, quantity: Math.max(1, quantity) } : i) };
+    notify();
+    void persist();
+}
+export function updateCheckoutForm(updates) {
+    state = { ...state, checkoutForm: { ...state.checkoutForm, ...updates } };
+    notify();
+    void persist();
+}
+export function clearCart() { state = { ...state, items: [] }; notify(); void persist(); }
+export function clearAll() { state = { items: [], checkoutForm: { ...defaultCheckoutForm } }; notify(); void persist(); }
+export const cartStore = {
+    getState: getCartState,
+    subscribe: subscribeCart,
+    getSnapshot: getCartSnapshot,
+    hydrate: hydrateCartStore,
+    addItem, removeItem, updateQuantity, updateCheckoutForm, clearCart, clearAll,
+};

package/dist/catalog/hooks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Catalog hooks — offline-first menu browsing
+ * Port of TeincFoodBusiness/src/hooks/menu.hooks.ts
+ * Uses reference_data SQLite cache + network refresh when online.
+ */
+import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
+export declare const CATALOG_KEYS: {
+    readonly all: readonly ["menu"];
+    readonly items: (businessId?: string) => readonly ["menu", "items", string | undefined];
+    readonly categories: (businessId?: string) => readonly ["menu", "categories", string | undefined];
+};
+export declare function useMenuItemsQuery(filters?: {
+    search?: string;
+    category_ids?: string;
+    sort?: string;
+}, enabled?: boolean): ReturnType<typeof useInfiniteQuery> & {
+    data: unknown[] | undefined;
+};
+export declare function useMenuCategoriesQuery(): ReturnType<typeof useQuery>;
+export declare function useCreateMenuItemMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, unknown>, unknown>;
+export declare function useUpdateMenuItemMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    id: string;
+    payload: Record<string, unknown>;
+}, unknown>;
+export declare function useDeleteMenuItemMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;

package/dist/catalog/hooks.js

@@ -0,0 +1,160 @@
+/**
+ * Catalog hooks — offline-first menu browsing
+ * Port of TeincFoodBusiness/src/hooks/menu.hooks.ts
+ * Uses reference_data SQLite cache + network refresh when online.
+ */
+import { useMemo } from "react";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+import { menuService } from "../adapters/services";
+import { getReferenceData } from "../reference/operations";
+import { openSyncDatabase } from "../db/connection";
+import { referenceSyncService } from "../reference/service";
+import { emitReferenceChanged } from "../reference/events";
+import { runOfflineCapableMutation } from "../sync/offline-capable";
+export const CATALOG_KEYS = {
+    all: ["menu"],
+    items: (businessId) => [...CATALOG_KEYS.all, "items", businessId],
+    categories: (businessId) => [...CATALOG_KEYS.all, "categories", businessId],
+};
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+function useIsOnline() {
+    const s = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    return s.isOnline;
+}
+export function useMenuItemsQuery(filters, enabled = true) {
+    const businessId = useBusinessId();
+    const isOnline = useIsOnline();
+    // Cached reference query — synchronous from SQLite via query
+    const cachedQuery = useQuery({
+        queryKey: [...CATALOG_KEYS.items(businessId), "cached", filters],
+        queryFn: async () => {
+            if (!businessId)
+                return null;
+            const db = await openSyncDatabase();
+            const rec = await getReferenceData(db, businessId, "menu:items");
+            return rec?.payload ?? null;
+        },
+        enabled: enabled && !!businessId,
+        staleTime: Infinity,
+    });
+    const filtered = useMemo(() => {
+        const all = cachedQuery.data?.data ?? [];
+        if (!enabled)
+            return [];
+        let out = all;
+        if (filters?.category_ids) {
+            const ids = new Set(filters.category_ids.split(",").map((s) => s.trim()).filter(Boolean));
+            if (ids.size > 0)
+                out = out.filter((i) => ids.has((i.category_id ?? i.categoryId) ?? ""));
+        }
+        if (filters?.search) {
+            const q = filters.search.trim().toLowerCase();
+            if (q)
+                out = out.filter((i) => (i.name ?? "").toLowerCase().includes(q) || (i.description ?? "").toLowerCase().includes(q));
+        }
+        return out;
+    }, [cachedQuery.data, filters?.category_ids, filters?.search, enabled]);
+    const networkQuery = useInfiniteQuery({
+        queryKey: [...CATALOG_KEYS.items(businessId), filters, "network"],
+        queryFn: ({ pageParam = 1 }) => menuService.fetchBusinessMenuItems(businessId, pageParam, filters),
+        initialPageParam: 1,
+        getNextPageParam: (lastPage) => {
+            const p = lastPage?.pagination;
+            return p && p.page < p.total_pages ? p.page + 1 : undefined;
+        },
+        enabled: enabled && !!businessId && isOnline,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+    const networkData = networkQuery.data?.pages
+        ? networkQuery.data.pages.flatMap((p) => p.data)
+        : undefined;
+    const data = isOnline && networkData !== undefined ? networkData : enabled ? filtered : undefined;
+    return {
+        data,
+        isPending: cachedQuery.isPending && !networkData,
+        isFetching: networkQuery.isFetching,
+        isError: cachedQuery.isError || networkQuery.isError,
+        error: (cachedQuery.error ?? networkQuery.error),
+        refetch: async () => {
+            if (!businessId)
+                return;
+            if (isOnline)
+                await referenceSyncService.sync({ businessId, keys: ["menu:items", "menu:categories"] });
+            return networkQuery.refetch();
+        },
+        fetchNextPage: networkQuery.fetchNextPage,
+        hasNextPage: networkQuery.hasNextPage,
+        isFetchingNextPage: networkQuery.isFetchingNextPage,
+    };
+}
+export function useMenuCategoriesQuery() {
+    const businessId = useBusinessId();
+    const isOnline = useIsOnline();
+    const cachedQuery = useQuery({
+        queryKey: [...CATALOG_KEYS.categories(businessId), "cached"],
+        queryFn: async () => {
+            if (!businessId)
+                return null;
+            const db = await openSyncDatabase();
+            const rec = await getReferenceData(db, businessId, "menu:categories");
+            return rec?.payload ?? null;
+        },
+        enabled: !!businessId,
+        staleTime: Infinity,
+    });
+    const networkQuery = useQuery({
+        queryKey: CATALOG_KEYS.categories(businessId),
+        queryFn: () => menuService.fetchBusinessCategories(businessId),
+        enabled: !!businessId && isOnline,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+    const data = (isOnline && networkQuery.data ? networkQuery.data : cachedQuery.data);
+    return { ...networkQuery, data, isPending: cachedQuery.isPending && !networkQuery.data };
+}
+// Mutations — offline-capable
+export function useCreateMenuItemMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (payload) => runOfflineCapableMutation({ run: () => menuService.createMenuItem(payload), commandType: "menu:create_item", businessId: businessId, payload }),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:items"]);
+        },
+    });
+}
+export function useUpdateMenuItemMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, payload }) => runOfflineCapableMutation({ run: () => menuService.updateMenuItem(id, payload), commandType: "menu:update_item", businessId: businessId, entityId: id, payload }),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:items"]);
+        },
+    });
+}
+export function useDeleteMenuItemMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => runOfflineCapableMutation({ run: () => menuService.deleteMenuItem(id), commandType: "menu:delete_item", businessId: businessId, entityId: id, payload: { id } }),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:items"]);
+        },
+    });
+}

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

@@ -45,9 +45,25 @@ export declare function useSellerOrdersQuery(enabled?: boolean, filters?: {
 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 function useSellerOrderQuery(orderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    data: SellerOrder;
+}, Error>;
+export declare function isQueuedTransition(result: unknown): boolean;
 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>;
+export declare function useConfirmHandoverMutation(): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    status: string;
+}, Error, string, unknown>;
+export declare function useAssignRiderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    orderId: string;
+    riderId: string;
+}, unknown>;
+export declare function useUpdateOrderStatusMutation(): {
+    mutate: (orderId: string, status: string) => Promise<unknown>;
+    isPending: boolean;
+};

package/dist/hooks/orders.hooks.js

@@ -272,6 +272,45 @@ export function usePOSOrderPreviewQuery(items, orderType, customerName) {
         staleTime: 30 * 1000,
     });
 }
+// ─── Seller order detail (offline via snapshot fallback) ───────────────────
+export function useSellerOrderQuery(orderId, enabled = true) {
+    const businessId = useBusinessId();
+    const connectivity = useConnectivity();
+    const offline = isOfflineState(connectivity);
+    return useQuery({
+        queryKey: SELLER_KEYS.order(orderId, businessId),
+        queryFn: async () => {
+            if (offline) {
+                const list = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
+                if (found)
+                    return { data: found };
+            }
+            try {
+                const res = await sellerService.fetchSellerOrder(orderId);
+                return res;
+            }
+            catch (e) {
+                const list = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
+                if (found)
+                    return { data: found };
+                throw e;
+            }
+        },
+        enabled: enabled && !!orderId && !!businessId,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+// ─── Helpers for queued UI ───────────────────────────────────────────────
+export function isQueuedTransition(result) {
+    const r = result;
+    if (!r)
+        return false;
+    return r.status === "pending" && !!r.command_id && !r.id;
+}
 // ─── Order status mutations via SyncEngine (all go through outbox) ────────
 function makeOrderActionMutation(build) {
     return function useOrderActionMutation() {
@@ -298,3 +337,57 @@ export const useStartPreparingOrderMutation = makeOrderActionMutation(({ orderId
 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 }));
+export function useConfirmHandoverMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (deliveryId) => {
+            if (!businessId)
+                throw new Error("No active business");
+            return orderRepository.confirmHandover({ deliveryId, businessId });
+        },
+        onSettled: (_d, _e, deliveryId) => {
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+            if (deliveryId)
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(deliveryId) });
+        },
+    });
+}
+export function useAssignRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ orderId, riderId }) => {
+            if (!businessId)
+                throw new Error("No active business");
+            return orderRepository.assignRider({ orderId, riderId, businessId });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+        },
+    });
+}
+export function useUpdateOrderStatusMutation() {
+    const accept = useAcceptOrderMutation();
+    const reject = useRejectOrderMutation();
+    const preparing = useStartPreparingOrderMutation();
+    const ready = useMarkOrderReadyMutation();
+    const complete = useCompletePickupMutation();
+    const cancel = useCancelOrderMutation();
+    return {
+        mutate: (orderId, status) => {
+            switch (status) {
+                case "accepted": return accept.mutateAsync(orderId);
+                case "preparing": return preparing.mutateAsync(orderId);
+                case "ready": return ready.mutateAsync(orderId);
+                case "delivered": return complete.mutateAsync(orderId);
+                case "cancelled": return cancel.mutateAsync(orderId);
+                case "rejected": return reject.mutateAsync(orderId);
+                default: throw new Error(`Unknown status ${status}`);
+            }
+        },
+        isPending: accept.isPending || reject.isPending || preparing.isPending || ready.isPending || complete.isPending || cancel.isPending,
+    };
+}

package/dist/image-cache/service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Image cache for offline reference — port of Business src/reference/image-cache.ts
+ * Durable documentDirectory cache (not cacheDirectory) with stable presigned URL keying.
+ * Host injects FileSystemAdapter; falls back to no-op on web.
+ */
+export interface ImageCacheEntry {
+    remoteUrl: string;
+    localUri: string | null;
+    etag: string | null;
+    lastModified: string | null;
+    cachedAt: string | null;
+}
+export declare function stableCacheUrl(url: string): string;
+export declare function getCachedImagePath(url: string): string;
+export declare function ensureImageCacheDir(): Promise<string>;
+export declare function getCachedImageInfo(url: string): Promise<ImageCacheEntry>;
+export declare function cacheRemoteImage(url: string | null | undefined, opts?: {
+    skipIfCached?: boolean;
+    removeOnFailure?: boolean;
+}): Promise<ImageCacheEntry | null>;
+export declare function cacheImageBatch(urls: (string | null | undefined)[], opts?: {
+    skipIfCached?: boolean;
+    removeOnFailure?: boolean;
+}): Promise<ImageCacheEntry[]>;
+export declare function clearImageCache(): Promise<void>;
+export declare function pruneImageCache(knownUrls: Iterable<string | null | undefined>, maxAgeDays?: number): Promise<number>;
+export declare function resolveImageSource(url: string | null | undefined): Promise<{
+    uri: string;
+} | null>;