@teincfood/core 0.7.9 → 0.8.1

package/dist/hooks/wallet.hooks.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Wallet hooks — offline-first. Balances and history serve the persisted
+ * query cache instantly offline; the network refreshes silently when online.
+ * (No SQLite wallet cache — the persisted TanStack cache is the offline
+ * source; both apps persist it.)
+ */
+import type { WalletBalanceResponse, WalletEntry } from "../types/api/wallet.api";
+export declare const WALLET_KEYS: {
+    all: readonly ["wallet"];
+    balance: (scope?: string) => readonly ["wallet", "balance", string | undefined];
+    history: (scope?: string) => readonly ["wallet", "history", string | undefined];
+};
+export declare function useAllBalancesQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<WalletBalanceResponse, Error>;
+export declare function useBusinessWalletBalanceQuery(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<WalletBalanceResponse, Error>;
+export declare function useWalletHistoryQuery(enabled?: boolean): {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    data: WalletEntry[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    data: WalletEntry[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    data: WalletEntry[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: 'success';
+    data: WalletEntry[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    data: WalletEntry[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<import("./use-infinite-list").ListPage<WalletEntry>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: 'success';
+    data: WalletEntry[] | undefined;
+};

package/dist/hooks/wallet.hooks.js

@@ -0,0 +1,56 @@
+/**
+ * Wallet hooks — offline-first. Balances and history serve the persisted
+ * query cache instantly offline; the network refreshes silently when online.
+ * (No SQLite wallet cache — the persisted TanStack cache is the offline
+ * source; both apps persist it.)
+ */
+import { useQuery } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { walletService } from "../adapters/services";
+import { useInfiniteList } from "./use-infinite-list";
+export const WALLET_KEYS = {
+    all: ["wallet"],
+    balance: (scope) => [...WALLET_KEYS.all, "balance", scope],
+    history: (scope) => [...WALLET_KEYS.all, "history", scope],
+};
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+export function useAllBalancesQuery(enabled = true) {
+    return useQuery({
+        queryKey: WALLET_KEYS.balance("all"),
+        queryFn: () => walletService.fetchAllBalances(),
+        enabled,
+        placeholderData: (prev) => prev,
+        staleTime: 30000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+export function useBusinessWalletBalanceQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useQuery({
+        queryKey: WALLET_KEYS.balance(businessId),
+        queryFn: () => walletService.fetchBusinessWalletBalance(businessId),
+        enabled: enabled && Boolean(businessId),
+        placeholderData: (prev) => prev,
+        staleTime: 30000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+export function useWalletHistoryQuery(enabled = true) {
+    const businessId = useBusinessId();
+    return useInfiniteList({
+        key: [...WALLET_KEYS.history(businessId)],
+        enabled: enabled && Boolean(businessId),
+        pageSize: 20,
+        staleTime: 30000,
+        onlineFetch: async (page, pageSize) => {
+            const res = (await walletService.fetchWalletHistory({ businessId, page, pageSize }));
+            return { data: res.data.entries, pagination: res.pagination };
+        },
+    });
+}

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

@@ -14,6 +14,34 @@ 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>;
+/**
+ * Only http(s) URLs can be fetched by the host downloader. Anything else
+ * (tfimg:// disk URIs leaked from another device, data:, blob:, file:)
+ * is either already local or unfetchable — attempting a download throws
+ * per-attempt errors (e.g. iOS NSURLError -1002) and, worse, feeds the
+ * hook's warm-then-invalidate cycle into an unbounded retry storm.
+ */
+export declare function isDownloadableImageUrl(url: string): boolean;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export declare function isLoadableImageUri(uri: string): boolean;
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export declare function toRenderableUri(uri: string | null | undefined): string | null;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export declare function toStorableImageUrl(value: string | null | undefined): string | null;
 export declare function cacheRemoteImage(url: string | null | undefined, opts?: {
     skipIfCached?: boolean;
     removeOnFailure?: boolean;

package/dist/image-cache/service.js

@@ -49,6 +49,53 @@ export async function getCachedImageInfo(url) {
     const info = await fs.getInfoAsync(localPath);
     return { remoteUrl: url, localUri: info.exists && !info.isDirectory ? localPath : null, etag: null, lastModified: null, cachedAt: info.exists ? new Date().toISOString() : null };
 }
+const DOWNLOADABLE_RE = /^https?:\/\//i;
+/**
+ * Only http(s) URLs can be fetched by the host downloader. Anything else
+ * (tfimg:// disk URIs leaked from another device, data:, blob:, file:)
+ * is either already local or unfetchable — attempting a download throws
+ * per-attempt errors (e.g. iOS NSURLError -1002) and, worse, feeds the
+ * hook's warm-then-invalidate cycle into an unbounded retry storm.
+ */
+export function isDownloadableImageUrl(url) {
+    return DOWNLOADABLE_RE.test(url);
+}
+const LOADABLE_RE = /^(https?|file|data|asset|content):/i;
+/**
+ * URI schemes React Native's `<Image>` can actually load on device. Anything
+ * else has no RCTImageURLLoader on iOS ("No suitable image URL loader
+ * found") and crashes the screen — notably `tfimg://` disk URIs leaked from
+ * desktop rows, bare S3 keys (`menus/biz/img.jpg`), and `blob:` preview
+ * URLs. The hook maps these to null so callers render their placeholder
+ * branch instead of feeding a fatal URI to the native loader.
+ */
+export function isLoadableImageUri(uri) {
+    return LOADABLE_RE.test(uri);
+}
+/** Map a resolved URI to one RN `<Image>` can load, else null (placeholder). */
+export function toRenderableUri(uri) {
+    if (!uri)
+        return null;
+    return isLoadableImageUri(uri) ? uri : null;
+}
+const URI_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Values safe to persist as a menu image reference: S3 keys, http(s) URLs,
+ * null. Preview URIs (tfimg:, blob:, file:, data:) must never be stored —
+ * the backend keeps non-http values verbatim and they poison every other
+ * device (mobile has no native loader for tfimg:// and crashes). Returns
+ * null for un-storable values, so re-saving a poisoned row self-heals it
+ * (caller re-uploads to restore the image).
+ */
+export function toStorableImageUrl(value) {
+    if (!value)
+        return null;
+    if (URI_SCHEME_RE.test(value) && !DOWNLOADABLE_RE.test(value)) {
+        syncLogger.warn("ImageCache", "Dropping un-storable image URL", { value: value.slice(0, 32) });
+        return null;
+    }
+    return value;
+}
 export async function cacheRemoteImage(url, opts = {}) {
     if (!url)
         return null;
@@ -58,9 +105,12 @@ export async function cacheRemoteImage(url, opts = {}) {
     await ensureImageCacheDir();
     const localPath = getCachedImagePath(url);
     const existing = await fs.getInfoAsync(localPath);
-    if (opts.skipIfCached && existing.exists && !existing.isDirectory) {
+    if (existing.exists && !existing.isDirectory) {
         return { remoteUrl: url, localUri: localPath, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
     }
+    if (!isDownloadableImageUrl(url)) {
+        return { remoteUrl: url, localUri: null, etag: null, lastModified: null, cachedAt: null };
+    }
     try {
         const res = await fs.downloadAsync(url, localPath);
         if (res.uri)
@@ -71,8 +121,6 @@ export async function cacheRemoteImage(url, opts = {}) {
     }
     if (opts.removeOnFailure)
         await fs.deleteAsync(localPath, { idempotent: true }).catch(() => { });
-    if (existing.exists && !existing.isDirectory)
-        return { remoteUrl: url, localUri: localPath, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
     return { remoteUrl: url, localUri: null, etag: null, lastModified: null, cachedAt: null };
 }
 export async function cacheImageBatch(urls, opts = {}) {

package/dist/index.d.ts

@@ -6,6 +6,9 @@
  */
 export * from "./types/api";
 export * from "./types/pos.types";
+export * from "./types/rider";
+export * from "./types/places";
+export * from "./adapters/notify";
 export { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./pricing/engine";
 export type { PricingInput, PricingResult } from "./pricing/engine";
 export * from "./utils/constants";
@@ -13,24 +16,39 @@ export * from "./utils/currency";
 export * from "./utils/error";
 export * from "./utils/uuid";
 export * from "./utils/sync-logger";
+export * from "./utils/debug-log";
+export * from "./utils/attempt-stats";
 export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
 export type { PhoneCountryOption } from "./utils/phone";
 export * from "./utils/formatCurrency";
 export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
-export * from "./utils/responsive";
+export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";
 export * from "./utils/customer-display";
 export * from "./utils/order-filter";
+export { useReferenceData } from "./reference/hooks";
+export { setNotifyHandlers } from "./adapters/notify";
+export { walletService, riderService, fleetService, deliveryService, dashboardService, analyticsService, placesService } from "./adapters/services";
+export { buildMenuItemEnvelope, buildMenuCategoryEnvelope } from "./reference/menu-record";
+export { validateMenuItemInput, validateMenuCategoryInput, validateOrderCreateInput, validateInviteInput } from "./validation/offline";
+export { useBusinessDeliveriesQuery } from "./hooks/delivery.hooks";
+export { useBusinessReferenceDataSync } from "./reference/hooks";
+export { createAppQueryClient, createQueryPersister } from "./providers/query-client";
+export { useSellerAnalyticsQuery } from "./hooks/analytics.hooks";
+export { useSellerDashboardQuery } from "./hooks/dashboard.hooks";
+export { useRealtimeInvalidation, useOrderRealtimeUpdates } from "./hooks/realtime-stubs";
+export { useAcceptFleetInvitationMutation, useAcceptBusinessInvitationMutation, useUserInvitationsQuery, } from "./hooks/members.hooks";
+export { useJoinRequestsQuery } from "./hooks/fleet.hooks";
 export * from "./db/migrations";
 export * from "./db/operations";
 export * as dbOps from "./db/operations";
 export { openSyncDatabase, getSyncDatabase, closeSyncDatabase } from "./db/connection";
 export * from "./sync/types";
+export * from "./sync/online-gates";
 export * from "./sync/use-sync-reconciliation";
 export { SyncEngine, syncEngine } from "./sync/engine";
 export * from "./sync/command-builder";
-export * from "./sync/command-queue.service";
 export { commandQueueService } from "./sync/command-queue.service";
 export { buildCommand } from "./sync/command-builder";
 export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber, generateOrderNumber, generateOrderNumberForBusiness, isOfflineOrderNumber, parseOrderNumber, resetCalloutForTests, } from "./sync/order-number";
@@ -53,29 +71,51 @@ export type { CreateOrderInput, AssignRiderInput, OrderActionInput } from "./rep
 export { posRepository } from "./repositories/pos.repository";
 export type { POSOrderPreviewInput } from "./repositories/pos.repository";
 export * from "./hooks/orders.hooks";
+export * from "./hooks/use-infinite-list";
+export * from "./hooks/wallet.hooks";
+export * from "./hooks/rider.hooks";
+export * from "./hooks/fleet.hooks";
+export * from "./hooks/delivery.hooks";
+export * from "./hooks/dashboard.hooks";
+export * from "./hooks/analytics.hooks";
+export * from "./hooks/members.hooks";
+export * from "./hooks/places.hooks";
+export * from "./hooks/offline-orders.hooks";
+export * from "./hooks/image.hooks";
+export * from "./hooks/realtime-stubs";
+export * from "./providers/query-client";
+export { KIOSK_KEYS, useKioskOrdersQuery, useAvailableRidersQuery, type AvailableRider, useAcceptKioskOrderMutation, useRejectKioskOrderMutation, useStartPreparingKioskOrderMutation, useMarkKioskOrderReadyMutation, } from "./hooks/kiosk.hooks";
 export * from "./reference/types";
 export * from "./reference/operations";
-export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher } from "./reference/api";
+export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher, setReferenceData, mergeReferenceData, setOperatingHoursLocal, setBusinessProfileLocal } from "./reference/api";
 export type { ReferenceLocalNodeFetcher } from "./reference/api";
 export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnReconnect, registerReferenceEventEngine, registerReferenceInvalidator } from "./reference/events";
 export * from "./reference/events";
 export * from "./reference/service";
+export * from "./reference/hooks";
 export { referenceSyncService } from "./reference/service";
+export * from "./reference/menu-record";
+export * from "./reference/menu-apply";
 export * from "./reference/capabilities";
 export * from "./adapters/sqlite";
 export { KVDriver, setKVDriver, getKVDriver, kvGetItem, kvSetItem, kvRemoveItem, getItem, setItem, removeItem, getItemSync, setItemSync } from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
-export * from "./adapters/local-node";
+export * from "./local-node/types";
+export * from "./local-node/store";
+export * from "./local-node/security";
+export * from "./local-node/adapters";
+export * from "./local-node/service";
+export { setLocalNodeState } from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
-export { setAuthProvider, getAuthToken } from "./adapters/auth";
+export { setAuthProvider, getAuthToken, setAuthRefreshProvider, getRefreshToken, setAuthTokensProvider, setAuthTokens, setAuthClearProvider, clearAuth } from "./adapters/auth";
 export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
 export * from "./adapters/print";
 export * from "./adapters/filesystem";
-export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
+export { SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
 export * from "./printer/types";
 export * from "./printer/store";
 export * from "./printer/receipt";
@@ -84,10 +124,20 @@ export * from "./printer/hooks";
 export * from "./cart/store";
 export * from "./cart/hooks";
 export * from "./catalog/hooks";
+export * from "./utils/order-transitions";
+export * from "./utils/business-hours";
+export * from "./hooks/business-hours.hooks";
+export * from "./domain/orders/service";
 export { phoenixSocket } from "./realtime/phoenix-socket";
 export { eventsService } from "./realtime/events.service";
 export { orderEventsService } from "./realtime/order-events.service";
 export { useEventsConnection } from "./realtime/useEventsConnection";
+export { getSyncJobsPendingCount, debugDumpSyncJobs, drainPending } from "./sync/sync-jobs.service";
+export { performFullSync } from "./sync/full-sync";
+export { stopHealthProbe } from "./sync/health-probe";
+export { notifyAuthChanged, subscribeAuth } from "./adapters/auth";
+export { ACCESS_EXPIRED_CODE, SESSION_DEAD_CODES, SKIP_AUTH_RETRY, extractAuthFailure, isAccessExpired, isSessionDead, hasAuthRetrySkip, refreshSession, withAuthRetry, } from "./auth/session";
+export type { AuthFailure, SessionTokens } from "./auth/session";
 export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 import { type SqliteDriver } from "./adapters/sqlite";
 import { type KVDriver } from "./adapters/kv";