@teincfood/core 0.7.8 → 0.8.0

package/dist/hooks/delivery.hooks.js

@@ -0,0 +1,80 @@
+/**
+ * Business deliveries hooks — single source for both apps.
+ * Offline-first: local orders with delivery_id serve instantly; the network
+ * refreshes silently when online.
+ */
+import { useSyncExternalStore } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { deliveryService } from "../adapters/services";
+import { listLocalOrders } from "../domain/orders/service";
+import { useInfiniteList, useIsEffectivelyOnline } from "./use-infinite-list";
+export const DELIVERY_KEYS = {
+    all: ["business-deliveries"],
+    list: (businessId, filters) => ["business-deliveries", businessId, filters],
+};
+export const DELIVERY_DETAIL_KEYS = {
+    all: ["delivery"],
+    detail: (id) => [...DELIVERY_DETAIL_KEYS.all, "detail", id],
+};
+export function useDeliveryDetailQuery(deliveryId, enabled = true) {
+    // No single-delivery SQLite mirror (list derives from local orders) —
+    // never fire while unreachable; persisted cache serves instead.
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: DELIVERY_DETAIL_KEYS.detail(deliveryId),
+        queryFn: () => deliveryService.fetchDeliveryDetail(deliveryId),
+        enabled: enabled && Boolean(deliveryId) && online,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+async function fetchOfflineDeliveries(businessId, filters, page, pageSize) {
+    const { data } = await listLocalOrders(businessId, { status: undefined, q: filters?.search }, page, pageSize);
+    const deliveryOrders = data.filter((o) => o.delivery_id);
+    const statusSet = new Set((filters?.status ?? "").split(",").map((s) => s.trim()).filter(Boolean));
+    const filtered = statusSet.size > 0
+        ? deliveryOrders.filter((o) => statusSet.has((o.status ?? "")))
+        : deliveryOrders;
+    const total = filtered.length;
+    const items = filtered.slice((page - 1) * pageSize, page * pageSize);
+    const mapped = items.map((o) => {
+        const order = o;
+        return {
+            id: order.delivery_id ?? order.id,
+            status: order.delivery_status ?? "assigned",
+            inserted_at: order.inserted_at,
+            rider: order.rider ?? null,
+            order,
+            merchant_handover_confirmed_at: null,
+            rider_pickup_confirmed_at: null,
+        };
+    });
+    return {
+        data: mapped,
+        pagination: { page, page_size: pageSize, total_pages: Math.max(1, Math.ceil(total / pageSize)), total_entries: total },
+    };
+}
+export function useBusinessDeliveriesQuery(enabled = true, filters) {
+    const businessId = useBusinessId();
+    return useInfiniteList({
+        key: DELIVERY_KEYS.list(businessId, filters),
+        enabled: enabled && Boolean(businessId),
+        pageSize: 20,
+        staleTime: 5000,
+        offlineFetch: (page, pageSize) => fetchOfflineDeliveries(businessId, filters, page, pageSize),
+        onlineFetch: async (page, pageSize) => {
+            const params = { page, page_size: pageSize };
+            if (filters?.status)
+                params.status = filters.status;
+            if (filters?.search)
+                params.search = filters.search;
+            const res = (await deliveryService.fetchBusinessDeliveries(businessId, params));
+            return res;
+        },
+    });
+}

package/dist/hooks/fleet.hooks.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fleet hooks — single source for both apps (previously verbatim copies).
+ * Reads serve cache instantly; network refreshes silently when online.
+ * Member/fleet management mutations require online (single source gates).
+ */
+import type { FleetVehicle } from "../types/api/fleet.api";
+export declare const FLEET_KEYS: {
+    all: readonly ["fleet"];
+    riders: (businessId?: string) => readonly ["fleet", "riders", string | undefined];
+    riderDetail: (id: string) => readonly ["fleet", "rider", string];
+    riderKyc: (id: string) => readonly ["fleet", "rider-kyc", string];
+    vehicles: (businessId?: string) => readonly ["fleet", "vehicles", string | undefined];
+    vehicleDetail: (id: string) => readonly ["fleet", "vehicle", string];
+    dashboard: (businessId?: string) => readonly ["fleet", "dashboard", string | undefined];
+    earnings: () => readonly ["fleet", "earnings"];
+    joinRequests: (businessId?: string) => readonly ["fleet", "join-requests", string | undefined];
+    invitations: (businessId?: string) => readonly ["fleet", "invitations", string | undefined];
+};
+export declare function useFleetRidersQuery(enabled?: boolean, filters?: {
+    q?: string;
+    status?: string;
+}): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useInviteRiderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, unknown>, unknown>;
+export declare function useFleetRiderQuery(riderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useRiderKycQuery(riderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useApproveRiderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useSuspendRiderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useActivateRiderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useJoinRequestsQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useApproveJoinRequestMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useRejectJoinRequestMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useFleetInvitationsQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useRevokeInvitationMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useFleetVehiclesQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useAddVehicleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, Partial<FleetVehicle>, unknown>;
+export declare function useRemoveVehicleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useFleetDashboardQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;

package/dist/hooks/fleet.hooks.js

@@ -0,0 +1,229 @@
+/**
+ * Fleet hooks — single source for both apps (previously verbatim copies).
+ * Reads serve cache instantly; network refreshes silently when online.
+ * Member/fleet management mutations require online (single source gates).
+ */
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { fleetService } from "../adapters/services";
+import { assertOnlineFor } from "../sync/online-gates";
+import { validateInviteInput } from "../validation/offline";
+import { useIsEffectivelyOnline } from "./use-infinite-list";
+export const FLEET_KEYS = {
+    all: ["fleet"],
+    riders: (businessId) => [...FLEET_KEYS.all, "riders", businessId],
+    riderDetail: (id) => [...FLEET_KEYS.all, "rider", id],
+    riderKyc: (id) => [...FLEET_KEYS.all, "rider-kyc", id],
+    vehicles: (businessId) => [...FLEET_KEYS.all, "vehicles", businessId],
+    vehicleDetail: (id) => [...FLEET_KEYS.all, "vehicle", id],
+    dashboard: (businessId) => [...FLEET_KEYS.all, "dashboard", businessId],
+    earnings: () => [...FLEET_KEYS.all, "earnings"],
+    joinRequests: (businessId) => [...FLEET_KEYS.all, "join-requests", businessId],
+    invitations: (businessId) => [...FLEET_KEYS.all, "invitations", businessId],
+};
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+const OFFLINE_FIRST = { retry: false, networkMode: "offlineFirst" };
+// Fleet has no SQLite mirror — offline source is the persisted query cache.
+// Reads are cache-first (no online gate): the query is enabled offline so
+// TanStack can serve stale cache + OfflineBanner marks not-live. Fetches still
+// fail gracefully via retry:false + offlineFirst when the network is down.
+function useOnline() {
+    return useIsEffectivelyOnline();
+}
+// ─── Riders ───
+export function useFleetRidersQuery(enabled = true, filters) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: [...FLEET_KEYS.riders(businessId), filters],
+        queryFn: () => fleetService.fetchFleetRiders(businessId, 1, 50, filters),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useInviteRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("member:invite");
+            validateInviteInput({ email: data.email ?? data.invited_email });
+            return fleetService.inviteRider(data, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.riders(businessId) });
+        },
+    });
+}
+export function useFleetRiderQuery(riderId, enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.riderDetail(riderId),
+        queryFn: () => fleetService.fetchFleetRider(riderId, businessId),
+        enabled: enabled && Boolean(riderId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useRiderKycQuery(riderId, enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.riderKyc(riderId),
+        queryFn: () => fleetService.fetchRiderKyc(riderId, businessId),
+        enabled: enabled && Boolean(riderId),
+        staleTime: 0,
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useApproveRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (riderId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.approveRider(riderId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.riders(businessId) });
+        },
+    });
+}
+export function useSuspendRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (riderId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.suspendRider(riderId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.riders(businessId) });
+        },
+    });
+}
+export function useActivateRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (riderId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.activateRider(riderId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.riders(businessId) });
+        },
+    });
+}
+export function useJoinRequestsQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.joinRequests(businessId),
+        queryFn: () => fleetService.fetchJoinRequests(businessId),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useApproveJoinRequestMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (requestId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.approveJoinRequest(requestId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.joinRequests(businessId) });
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.riders(businessId) });
+        },
+    });
+}
+export function useRejectJoinRequestMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (requestId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.rejectJoinRequest(requestId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.joinRequests(businessId) });
+        },
+    });
+}
+export function useFleetInvitationsQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.invitations(businessId),
+        queryFn: () => fleetService.fetchInvitations(businessId),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useRevokeInvitationMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (invitationId) => {
+            assertOnlineFor("member:manage");
+            return fleetService.revokeInvitation(invitationId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.invitations(businessId) });
+        },
+    });
+}
+// ─── Vehicles ───
+export function useFleetVehiclesQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.vehicles(businessId),
+        queryFn: () => fleetService.fetchFleetVehicles(businessId),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useAddVehicleMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("fleet:manage");
+            return fleetService.addVehicle(data, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.vehicles(businessId) });
+        },
+    });
+}
+export function useRemoveVehicleMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (vehicleId) => {
+            assertOnlineFor("fleet:manage");
+            return fleetService.removeVehicle(vehicleId, businessId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: FLEET_KEYS.vehicles(businessId) });
+        },
+    });
+}
+// ─── Dashboard ───
+export function useFleetDashboardQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: FLEET_KEYS.dashboard(businessId),
+        queryFn: () => fleetService.fetchFleetDashboard(businessId),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        ...OFFLINE_FIRST,
+    });
+}

package/dist/hooks/image.hooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Offline-first image source resolution — single source for both apps.
+ *
+ * Returns the durable local file path when cached, otherwise the remote URL.
+ * While online, uncached images warm in the background. Falls back to remote
+ * so online behavior is unchanged.
+ */
+import { useQueryClient } from "@tanstack/react-query";
+export declare const IMAGE_CACHE_KEYS: {
+    all: readonly ["cachedImage"];
+    url: (url: string) => readonly ["cachedImage", string];
+};
+export declare const CACHED_IMAGE_KEYS: {
+    all: readonly ["cachedImage"];
+    url: (url: string) => readonly ["cachedImage", string];
+};
+/** Invalidate every cached-image query (e.g. after a bulk reference sync). */
+export declare function invalidateCachedImages(queryClient: ReturnType<typeof useQueryClient>): void;
+/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+export declare function useCachedImageUrl(url: string | null | undefined): string | null;

package/dist/hooks/image.hooks.js

@@ -0,0 +1,62 @@
+/**
+ * Offline-first image source resolution — single source for both apps.
+ *
+ * Returns the durable local file path when cached, otherwise the remote URL.
+ * While online, uncached images warm in the background. Falls back to remote
+ * so online behavior is unchanged.
+ */
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+import { cacheRemoteImage, getCachedImageInfo, resolveImageSource, stableCacheUrl } from "../image-cache/service";
+export const IMAGE_CACHE_KEYS = {
+    all: ["cachedImage"],
+    url: (url) => ["cachedImage", url],
+};
+export const CACHED_IMAGE_KEYS = IMAGE_CACHE_KEYS;
+/** Invalidate every cached-image query (e.g. after a bulk reference sync). */
+export function invalidateCachedImages(queryClient) {
+    queryClient.invalidateQueries({ queryKey: IMAGE_CACHE_KEYS.all });
+}
+/** Resolve an image URL to a URI. Prefers local cache; null for null URL. */
+export function useCachedImageUrl(url) {
+    const queryClient = useQueryClient();
+    const connectivity = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    const isOnline = connectivity.isOnline;
+    const enabled = Boolean(url);
+    const { data } = useQuery({
+        queryKey: IMAGE_CACHE_KEYS.url(stableCacheUrl(url ?? "__none__")),
+        queryFn: async () => {
+            if (!url)
+                return null;
+            const resolved = await resolveImageSource(url);
+            if (!resolved)
+                return { uri: url };
+            if (resolved.uri === url && isOnline) {
+                // Warm in the background, but refresh this query ONLY if warming
+                // actually landed the file. Unconditional invalidate-after-warm
+                // turns every permanent failure (offline race, unfetchable URL)
+                // into an unbounded refetch → warm → fail loop.
+                cacheRemoteImage(url, { skipIfCached: true })
+                    .then(async () => {
+                    try {
+                        const fresh = await getCachedImageInfo(url);
+                        if (fresh.localUri) {
+                            queryClient.invalidateQueries({ queryKey: IMAGE_CACHE_KEYS.url(stableCacheUrl(url)) });
+                        }
+                    }
+                    catch { }
+                })
+                    .catch(() => { });
+            }
+            return resolved;
+        },
+        enabled,
+        staleTime: 5 * 60 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+    if (!enabled || !data)
+        return null;
+    return data.uri;
+}

package/dist/hooks/kiosk.hooks.d.ts

@@ -1,5 +1,22 @@
-/**
- * Kiosk hooks shim — delegates to order lifecycle hooks for offline-first.
- * Kiosk is just a filtered view of seller orders; transitions use the same outbox.
- */
-export { useAcceptOrderMutation as useAcceptKioskOrderMutation, useRejectOrderMutation as useRejectKioskOrderMutation, useStartPreparingOrderMutation as useStartPreparingKioskOrderMutation, useMarkOrderReadyMutation as useMarkKioskOrderReadyMutation, } from "./orders.hooks";
+export interface AvailableRider {
+    id: string;
+    name: string;
+    phone: string | null;
+    vehicle_type: string | null;
+    rating: null;
+    distance: null;
+}
+export declare const KIOSK_KEYS: {
+    all: readonly ["kiosk"];
+    orders: (bid?: string) => readonly ["kiosk", "orders", string | undefined];
+    riders: (bid?: string) => readonly ["kiosk", "riders", string | undefined];
+};
+export declare function useKioskOrdersQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    data: import("..").SellerOrder[];
+}, Error>;
+export declare function useAvailableRidersQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<AvailableRider[], Error>;
+export declare const useAcceptKioskOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useRejectKioskOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useStartPreparingKioskOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare const useMarkKioskOrderReadyMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export { useAssignRiderMutation } from "./orders.hooks";

package/dist/hooks/kiosk.hooks.js

@@ -1,5 +1,74 @@
-/**
- * Kiosk hooks shim — delegates to order lifecycle hooks for offline-first.
- * Kiosk is just a filtered view of seller orders; transitions use the same outbox.
- */
-export { useAcceptOrderMutation as useAcceptKioskOrderMutation, useRejectOrderMutation as useRejectKioskOrderMutation, useStartPreparingOrderMutation as useStartPreparingKioskOrderMutation, useMarkOrderReadyMutation as useMarkKioskOrderReadyMutation, } from "./orders.hooks";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { fleetService } from "../adapters/services";
+import { listLocalOrders } from "../domain/orders/service";
+import { orderRepository } from "../repositories/order.repository";
+import { mergePendingIntoList } from "../sync/pending-orders.service";
+export const KIOSK_KEYS = { all: ["kiosk"], orders: (bid) => [...KIOSK_KEYS.all, "orders", bid], riders: (bid) => [...KIOSK_KEYS.all, "riders", bid] };
+function useBusinessId() { const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null); return id ?? undefined; }
+export function useKioskOrdersQuery(enabled = true) {
+    const bid = useBusinessId();
+    return useQuery({
+        queryKey: KIOSK_KEYS.orders(bid),
+        queryFn: async () => {
+            if (!bid)
+                return { data: [] };
+            const { data } = await listLocalOrders(bid, {}, 1, 100);
+            return { data: await mergePendingIntoList(data, bid, 1) };
+        },
+        enabled: enabled && !!bid,
+        staleTime: 5 * 1000,
+    });
+}
+export function useAvailableRidersQuery(enabled = true) {
+    const bid = useBusinessId();
+    return useQuery({
+        queryKey: KIOSK_KEYS.riders(bid),
+        queryFn: async () => {
+            const res = (await fleetService.fetchFleetRiders(bid, 1, 50));
+            return (res?.data ?? []).map((rider) => ({
+                id: rider.id,
+                name: rider.user?.full_name || rider.rider_number || "Rider",
+                phone: rider.phone || null,
+                vehicle_type: rider.vehicle?.type || null,
+                rating: null,
+                distance: null,
+            }));
+        },
+        enabled: enabled && !!bid,
+        placeholderData: (prev) => prev,
+        staleTime: 0,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+const KIOSK_ACTIONS = {
+    accept: (p) => orderRepository.acceptOrder(p),
+    reject: (p) => orderRepository.rejectOrder(p),
+    start_preparing: (p) => orderRepository.startPreparingOrder(p),
+    mark_ready: (p) => orderRepository.markOrderReady(p),
+};
+function makeKioskMutation(action) {
+    return function useKioskMutation() {
+        const bid = useBusinessId();
+        const qc = useQueryClient();
+        return useMutation({
+            mutationFn: (orderId) => {
+                if (!bid)
+                    throw new Error("No active business");
+                const run = KIOSK_ACTIONS[action];
+                if (!run)
+                    throw new Error(`Unknown kiosk action ${action}`);
+                // Engine route (cloud → LAN → queue) so peers converge.
+                return run({ orderId, businessId: bid });
+            },
+            onSuccess: () => { qc.invalidateQueries({ queryKey: KIOSK_KEYS.orders(bid) }); qc.invalidateQueries({ queryKey: ["seller"] }); },
+        });
+    };
+}
+export const useAcceptKioskOrderMutation = makeKioskMutation("accept");
+export const useRejectKioskOrderMutation = makeKioskMutation("reject");
+export const useStartPreparingKioskOrderMutation = makeKioskMutation("start_preparing");
+export const useMarkKioskOrderReadyMutation = makeKioskMutation("mark_ready");
+export { useAssignRiderMutation } from "./orders.hooks";

package/dist/hooks/members.hooks.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Members / invitations / roles / tax hooks — single source for both apps.
+ * Reads serve the SQLite reference cache instantly; network refreshes
+ * silently when online. Invites and management mutations require online.
+ */
+export declare const MEMBER_KEYS: {
+    all: readonly ["business-members"];
+    list: (businessId?: string) => readonly ["business-members", string | undefined];
+    invitations: (businessId?: string) => readonly ["business-members", string | undefined, "invitations"];
+};
+export declare const INVITATION_KEYS: {
+    all: readonly ["invitations"];
+    list: () => readonly ["invitations", "list"];
+};
+export declare const ROLES_KEYS: {
+    all: readonly ["business-roles"];
+    forBusiness: (businessId?: string) => readonly ["business-roles", string | undefined];
+};
+export declare const TAX_KEYS: {
+    all: readonly ["tax-rules"];
+    list: (businessId?: string) => readonly ["tax-rules", "list", string | undefined];
+};
+export declare function useBusinessMembersQuery(): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useInviteMemberMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    email?: string;
+    phone?: string;
+    role?: string;
+}, unknown>;
+export declare function useRemoveMemberMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useBusinessMemberInvitationsQuery(): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useRevokeMemberInvitationMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useDeleteMemberInvitationMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useUserInvitationsQuery(): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useLeaveBusinessMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useAcceptFleetInvitationMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    code: string;
+}, unknown>;
+export declare function useAcceptBusinessInvitationMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    code: string;
+}, unknown>;
+export declare function useBusinessRolesQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useBusinessTaxRulesQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare function useCreateTaxRuleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, unknown>, unknown>;
+export declare function useUpdateTaxRuleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    id: string;
+    data: Record<string, unknown>;
+}, unknown>;
+export declare function useDeleteTaxRuleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;