@teincfood/core 0.7.8 → 0.8.0

package/dist/realtime/events.service.js

@@ -0,0 +1,76 @@
+import { phoenixSocket } from "./phoenix-socket";
+class EventsService {
+    constructor() {
+        this.refCount = 0;
+        this.topic = null;
+        this.joined = false;
+        this.lastSequence = 0;
+        this.activeBusinessId = null;
+        this.listeners = new Map();
+        this.wildcardListeners = new Set();
+        this.frameHandlerUnsub = null;
+    }
+    connect(userId, businessId) {
+        this.refCount++;
+        const topic = `events:${userId}`;
+        if (businessId !== undefined)
+            this.activeBusinessId = businessId ?? null;
+        if (this.refCount === 1 && !this.frameHandlerUnsub) {
+            this.topic = topic;
+            this.frameHandlerUnsub = phoenixSocket.onFrame(topic, ([_joinRef, _ref, _topic, event, payload]) => {
+                const data = payload;
+                const payloadBid = data?.business_id;
+                if (this.activeBusinessId && payloadBid && payloadBid !== this.activeBusinessId)
+                    return;
+                const sequence = data?._sequence;
+                if (typeof sequence === "number" && sequence <= this.lastSequence)
+                    return;
+                if (typeof sequence === "number" && sequence > this.lastSequence)
+                    this.lastSequence = sequence;
+                else if (typeof data?._sequence === "number")
+                    this.lastSequence = data._sequence;
+                const typeListeners = this.listeners.get(event);
+                if (typeListeners)
+                    typeListeners.forEach((cb) => cb(data));
+                this.wildcardListeners.forEach((cb) => cb(data));
+            });
+            const joinPayload = {};
+            if (this.lastSequence > 0)
+                joinPayload.last_sequence = this.lastSequence;
+            if (this.activeBusinessId)
+                joinPayload.business_id = this.activeBusinessId;
+            phoenixSocket.connect().then(() => phoenixSocket.joinChannel(topic, joinPayload)).then(() => { this.joined = true; }).catch(() => { });
+        }
+        else if (businessId !== undefined) {
+            // business switched while already joined — update filter without rejoin (next events filtered). If backend requires business:{id} subscription, re-join could be forced — not needed as fallback business_authorized check still passes.
+            this.activeBusinessId = businessId ?? null;
+        }
+        let disconnected = false;
+        return () => {
+            if (disconnected)
+                return;
+            disconnected = true;
+            this.refCount = Math.max(0, this.refCount - 1);
+            if (this.refCount === 0) {
+                if (this.topic && this.joined)
+                    phoenixSocket.leaveChannel(this.topic);
+                this.frameHandlerUnsub?.();
+                this.frameHandlerUnsub = null;
+                this.joined = false;
+                this.topic = null;
+                // reset sequence on full disconnect so next user doesn't dedup? Keep until next connect with same user - if user changes, lastSequence should reset. Caller should ensure new userId -> new instance or reset.
+                // Keep for replay.
+            }
+        };
+    }
+    on(eventType, callback) {
+        if (!this.listeners.has(eventType))
+            this.listeners.set(eventType, new Set());
+        this.listeners.get(eventType).add(callback);
+        return () => { this.listeners.get(eventType)?.delete(callback); };
+    }
+    onAny(callback) { this.wildcardListeners.add(callback); return () => this.wildcardListeners.delete(callback); }
+    isConnected() { return this.joined && phoenixSocket.isConnected(); }
+    resetSequence() { this.lastSequence = 0; }
+}
+export const eventsService = new EventsService();

package/dist/realtime/order-events.service.d.ts

@@ -0,0 +1,6 @@
+export declare const orderEventsService: {
+    onOrderUpdates(callback: (event: Record<string, unknown> & {
+        type: string;
+        order_id?: string;
+    }) => void): () => void;
+};

package/dist/realtime/order-events.service.js

@@ -0,0 +1,17 @@
+import { eventsService } from "./events.service";
+const ORDER_EVENT_TYPES = [
+    "order.created",
+    "order.status_changed",
+    "delivery.assigned",
+    "delivery.status_changed",
+    "delivery.pickup_confirmed",
+    "payment.completed",
+    "payment.failed",
+    "reference_data.changed",
+];
+export const orderEventsService = {
+    onOrderUpdates(callback) {
+        const unsubs = ORDER_EVENT_TYPES.map((type) => eventsService.on(type, (data) => callback({ ...data, type })));
+        return () => unsubs.forEach((fn) => fn());
+    },
+};

package/dist/realtime/phoenix-socket.d.ts

@@ -0,0 +1,55 @@
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
+export type PhoenixV2Frame = [string | null, string | null, string, string, Record<string, unknown>];
+export type PhoenixOutbound = {
+    topic: string;
+    event: string;
+    payload: Record<string, unknown>;
+    ref?: string | null;
+    joinRef?: string | null;
+};
+type FrameHandler = (frame: PhoenixV2Frame) => void;
+declare class PhoenixSocket {
+    socket: WebSocket | null;
+    private refCounter;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private heartbeatPend;
+    private heartbeatMissed;
+    private static readonly MAX_MISSED;
+    private intentionalClose;
+    private connectGen;
+    private connectPromise;
+    private connectionState;
+    private connectionListeners;
+    private pendingJoins;
+    private pendingPushes;
+    joinedChannels: Set<string>;
+    private pendingRejoin;
+    private topicJoinRefs;
+    private frameHandlers;
+    private getRef;
+    private buildSocketUrl;
+    private setState;
+    onConnectionStateChange(fn: (s: ConnectionState) => void): () => void;
+    getConnectionState(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): void;
+    retryConnection(): void;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendRaw;
+    push(topic: string, event: string, payload: Record<string, unknown>): void;
+    pushWithReply(topic: string, event: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private handleFrame;
+    onFrame(topic: string, handler: FrameHandler): () => void;
+    joinChannel(topic: string, payload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    leaveChannel(topic: string): void;
+    private rejoinPending;
+    isConnected(): boolean;
+    hasJoined(topic: string): boolean;
+}
+export declare const phoenixSocket: PhoenixSocket;
+export {};

package/dist/realtime/phoenix-socket.js

@@ -0,0 +1,269 @@
+import { WS_BASE_URL } from "../utils/constants";
+import { getAuthToken } from "../adapters/auth";
+import { getConnectivityState } from "../adapters/connectivity";
+import { recordAttempt } from "../utils/attempt-stats";
+import { syncLogger } from "../utils/sync-logger";
+const RECONNECT_BASE = 1000;
+const RECONNECT_MAX = 10000;
+const HEARTBEAT_MS = 30000;
+class PhoenixSocket {
+    constructor() {
+        this.socket = null;
+        this.refCounter = 0;
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.intentionalClose = false;
+        this.connectGen = 0;
+        this.connectPromise = null;
+        this.connectionState = "disconnected";
+        this.connectionListeners = new Set();
+        this.pendingJoins = new Map();
+        this.pendingPushes = new Map();
+        this.joinedChannels = new Set();
+        this.pendingRejoin = new Set();
+        this.topicJoinRefs = new Map();
+        this.frameHandlers = new Map();
+    }
+    getRef() { return String(++this.refCounter); }
+    buildSocketUrl(token) {
+        const base = WS_BASE_URL.replace(/\/+$/, "");
+        const path = base.endsWith("/ws") ? "/websocket" : "/ws/websocket";
+        return `${base}${path}?token=${encodeURIComponent(token)}&vsn=2.0.0`;
+    }
+    setState(s) {
+        this.connectionState = s;
+        this.connectionListeners.forEach((fn) => fn(s));
+    }
+    onConnectionStateChange(fn) {
+        this.connectionListeners.add(fn);
+        return () => this.connectionListeners.delete(fn);
+    }
+    getConnectionState() { return this.connectionState; }
+    connect() {
+        if (this.socket?.readyState === WebSocket.OPEN)
+            return Promise.resolve();
+        if (this.connectPromise)
+            return this.connectPromise;
+        // Offline-first: don't even open a socket when the cloud is known
+        // unreachable — the browser logs a WS error per attempt otherwise.
+        try {
+            if (getConnectivityState().isCloudReachable === "unreachable") {
+                this.scheduleReconnect();
+                return Promise.reject(new Error("Offline — cloud unreachable"));
+            }
+        }
+        catch { }
+        recordAttempt("ws_connect");
+        this.cancelReconnect();
+        this.intentionalClose = false;
+        this.setState("connecting");
+        this.connectPromise = new Promise((resolve, reject) => {
+            const token = getAuthToken();
+            if (!token) {
+                this.setState("disconnected");
+                this.connectPromise = null;
+                reject(new Error("Not authenticated"));
+                return;
+            }
+            const myGen = ++this.connectGen;
+            const url = this.buildSocketUrl(token);
+            this.socket = new WebSocket(url);
+            this.socket.onopen = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.reconnectAttempt = 0;
+                this.setState("connected");
+                this.startHeartbeat();
+                this.rejoinPending().catch(() => { });
+                this.connectPromise = null;
+                resolve();
+            };
+            this.socket.onerror = () => { if (myGen !== this.connectGen)
+                return; if (this.connectionState === "connecting") {
+                this.setState("disconnected");
+                this.connectPromise = null;
+            } };
+            this.socket.onmessage = (ev) => { try {
+                const frame = JSON.parse(ev.data);
+                this.handleFrame(frame);
+            }
+            catch { } };
+            this.socket.onclose = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.stopHeartbeat();
+                if (!this.intentionalClose) {
+                    this.joinedChannels.forEach((t) => this.pendingRejoin.add(t));
+                    this.joinedChannels.clear();
+                    this.scheduleReconnect();
+                }
+                else {
+                    this.joinedChannels.clear();
+                    this.pendingRejoin.clear();
+                    this.setState("disconnected");
+                }
+                this.connectPromise = null;
+            };
+        });
+        return this.connectPromise;
+    }
+    disconnect() {
+        this.intentionalClose = true;
+        this.cancelReconnect();
+        this.stopHeartbeat();
+        this.joinedChannels.clear();
+        this.pendingRejoin.clear();
+        this.pendingJoins.clear();
+        this.pendingPushes.clear();
+        this.topicJoinRefs.clear();
+        this.frameHandlers.clear();
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+        this.setState("disconnected");
+        this.connectPromise = null;
+    }
+    retryConnection() { this.cancelReconnect(); this.reconnectAttempt = 0; this.connect().catch(() => { }); }
+    scheduleReconnect() {
+        if (this.intentionalClose)
+            return;
+        this.setState("reconnecting");
+        // Offline-first: when the cloud is known unreachable (backend down),
+        // back off to a slow 60s poll instead of the 1s→10s hot loop — the
+        // useEventsConnection gate + probe regain path re-establishes fast.
+        let unreachable = false;
+        try {
+            unreachable = getConnectivityState().isCloudReachable === "unreachable";
+        }
+        catch { }
+        const delay = unreachable
+            ? 60000
+            : Math.min(RECONNECT_BASE * Math.pow(2, this.reconnectAttempt), RECONNECT_MAX);
+        this.reconnectAttempt++;
+        recordAttempt("ws_reconnect", `delay=${delay} attempt=${this.reconnectAttempt}`);
+        try {
+            syncLogger.debug("PhoenixSocket", "scheduleReconnect", { delay, attempt: this.reconnectAttempt });
+        }
+        catch { }
+        this.reconnectTimer = setTimeout(() => this.connect().catch(() => { }), delay);
+    }
+    cancelReconnect() { if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    } }
+    startHeartbeat() {
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.heartbeatTimer = setInterval(() => {
+            recordAttempt("ws_heartbeat", `missed=${this.heartbeatMissed}`);
+            if (this.heartbeatPend) {
+                this.heartbeatMissed++;
+                if (this.heartbeatMissed >= PhoenixSocket.MAX_MISSED)
+                    this.socket?.close();
+                return;
+            }
+            this.heartbeatPend = true;
+            this.sendRaw({ topic: "phoenix", event: "heartbeat", payload: {} });
+        }, HEARTBEAT_MS);
+    }
+    stopHeartbeat() { if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+    } this.heartbeatPend = false; this.heartbeatMissed = 0; }
+    sendRaw(msg) {
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            const joinRef = msg.topic && msg.topic !== "phoenix" ? (msg.joinRef ?? this.topicJoinRefs.get(msg.topic) ?? null) : (msg.joinRef ?? null);
+            const frame = [joinRef, msg.ref ?? null, msg.topic, msg.event, msg.payload];
+            this.socket.send(JSON.stringify(frame));
+        }
+    }
+    push(topic, event, payload) { const ref = this.getRef(); this.sendRaw({ topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) }); }
+    pushWithReply(topic, event, payload) {
+        const ref = this.getRef();
+        const msg = { topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) };
+        return new Promise((resolve, reject) => {
+            this.pendingPushes.set(ref, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingPushes.has(ref)) {
+                this.pendingPushes.delete(ref);
+                reject(new Error(`Request timed out: ${event} on ${topic}`));
+            } }, 5000);
+        });
+    }
+    handleFrame([joinRef, ref, topic, event, payload]) {
+        if (event === "phx_reply" && topic === "phoenix") {
+            this.heartbeatPend = false;
+            this.heartbeatMissed = 0;
+            return;
+        }
+        if (event === "phx_reply" && ref) {
+            const pending = this.pendingPushes.get(ref);
+            if (pending) {
+                const status = payload?.status;
+                const response = (payload?.response ?? {});
+                if (status === "ok")
+                    pending.resolve(response);
+                else
+                    pending.reject(new Error(String(response.reason ?? "Request failed")));
+                this.pendingPushes.delete(ref);
+                return;
+            }
+        }
+        if (event === "phx_reply" && payload?.status === "ok") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.resolve(response);
+                this.pendingJoins.delete(topic);
+                this.joinedChannels.add(topic);
+                if (joinRef)
+                    this.topicJoinRefs.set(topic, joinRef);
+            }
+            return;
+        }
+        if (event === "phx_reply" && payload?.status === "error") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.reject(new Error(String(response.reason ?? "Join failed")));
+                this.pendingJoins.delete(topic);
+            }
+            return;
+        }
+        const handlers = this.frameHandlers.get(topic);
+        if (handlers)
+            handlers.forEach((cb) => cb([joinRef, ref, topic, event, payload]));
+    }
+    onFrame(topic, handler) {
+        if (!this.frameHandlers.has(topic))
+            this.frameHandlers.set(topic, new Set());
+        this.frameHandlers.get(topic).add(handler);
+        return () => { this.frameHandlers.get(topic)?.delete(handler); };
+    }
+    async joinChannel(topic, payload = {}) {
+        if (this.joinedChannels.has(topic))
+            return Promise.resolve({});
+        if (this.pendingJoins.has(topic))
+            return new Promise((resolve, reject) => { this.pendingJoins.set(topic, { resolve, reject }); });
+        const ref = this.getRef();
+        const msg = { topic, event: "phx_join", payload, ref };
+        return new Promise((resolve, reject) => {
+            this.pendingJoins.set(topic, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingJoins.has(topic)) {
+                this.pendingJoins.delete(topic);
+                reject(new Error(`Failed to join channel ${topic} - timeout`));
+            } }, 5000);
+        });
+    }
+    leaveChannel(topic) { this.joinedChannels.delete(topic); this.pendingRejoin.delete(topic); this.topicJoinRefs.delete(topic); }
+    async rejoinPending() { const topics = Array.from(this.pendingRejoin); this.pendingRejoin.clear(); await Promise.allSettled(topics.map((t) => this.joinChannel(t))); }
+    isConnected() { return this.socket?.readyState === WebSocket.OPEN; }
+    hasJoined(topic) { return this.joinedChannels.has(topic); }
+}
+PhoenixSocket.MAX_MISSED = 3;
+export const phoenixSocket = new PhoenixSocket();

package/dist/realtime/useEventsConnection.d.ts

@@ -0,0 +1 @@
+export declare function useEventsConnection(): void;

package/dist/realtime/useEventsConnection.js

@@ -0,0 +1,50 @@
+import { useEffect } from "react";
+import { eventsService } from "./events.service";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getAuthToken } from "../adapters/auth";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+function useBusinessId() {
+    return useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+}
+function useIsAuthenticated() {
+    // poll auth token presence; host should setAuthProvider — if no provider, assume authenticated when token exists
+    return !!getAuthToken();
+}
+function useIsEffectivelyOnline() {
+    const s = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    return s.isOnline && s.isCloudReachable !== "unreachable";
+}
+export function useEventsConnection() {
+    const activeBusinessId = useBusinessId();
+    // derive userId from auth token? Host must provide via setAuthProvider that encodes user, but we need userId for topic.
+    // For now, read from global if host set it via setAuthUserId adapter. Fallback: token payload decode.
+    // Minimal: require host to call eventsService.connect with userId directly via wrapper — this hook is convenience that reads business only.
+    // To keep zero-config, we attempt to read from window localStorage token decode — fallback no-op.
+    const userId = deriveUserId();
+    // Offline-first: never open the Phoenix socket while the cloud is known
+    // unreachable (backend down). Connecting anyway just spins the 1s→10s
+    // reconnect loop and spams WS errors. Reconnect fires via effect dep.
+    const online = useIsEffectivelyOnline();
+    useEffect(() => {
+        if (!userId || !online)
+            return;
+        const disconnect = eventsService.connect(userId, activeBusinessId);
+        return () => disconnect();
+    }, [userId, activeBusinessId, online]);
+}
+function deriveUserId() {
+    try {
+        const token = getAuthToken();
+        if (!token)
+            return null;
+        const parts = token.split(".");
+        if (parts.length < 2)
+            return null;
+        const payload = JSON.parse(atob(parts[1]));
+        return payload.sub || payload.user_id || payload.id || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/reference/api.d.ts

@@ -25,3 +25,5 @@ export declare function fetchReferenceVersions(businessId: string): Promise<Refe
  */
 export declare function fetchReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<Record<ReferenceDataKey, unknown>>;
 export declare function fetchReferenceChanges<T>(businessId: string, key: ReferenceDataKey, fromVersion: string): Promise<ReferenceChangeSet<T>>;
+export { setReferenceData, mergeReferenceData } from "./operations";
+export { setOperatingHoursLocal, setBusinessProfileLocal } from "./operations";

package/dist/reference/api.js

@@ -40,3 +40,5 @@ export async function fetchReferenceChanges(businessId, key, fromVersion) {
     const response = await api.get(`/businesses/${businessId}/reference-changes`, { params: { key, from_version: fromVersion } });
     return response.data.data;
 }
+export { setReferenceData, mergeReferenceData } from "./operations";
+export { setOperatingHoursLocal, setBusinessProfileLocal } from "./operations";

package/dist/reference/capabilities.d.ts

@@ -8,16 +8,21 @@
  *
  * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
  */
+import { useQuery } from "@tanstack/react-query";
 /**
  * Standard hook for both apps — businessId comes from the host's active business store.
- * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ * Offline-first: when offline, only the SQLite cache (`capabilities`) is used so
+ * nav filtering (menu/pos/orders/deliveries hidden) does not break when backend is down.
+ * When online, network refreshes the cache.
  */
-export declare function useBusinessCapabilities(businessId?: string | null): import("@tanstack/react-query").UseQueryResult<{
-    role: string;
-    source: string;
-    capabilities: string[];
-    status: string;
-}, Error>;
+export declare function useBusinessCapabilities(businessId?: string | null): ReturnType<typeof useQuery> & {
+    data: {
+        role: string;
+        source: string;
+        capabilities: string[];
+        status: string;
+    } | undefined;
+};
 export declare function useHasCapabilityFor(businessId: string | undefined, capability: string): boolean;
 export declare const CAPABILITY_BY_COMMAND: Record<string, string>;
 export declare function hasCapabilitySync(businessId: string, commandType: string): Promise<boolean>;

package/dist/reference/capabilities.js

@@ -9,10 +9,11 @@
  * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
  */
 import { useEffect, useState } from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useQuery } from "@tanstack/react-query";
 import { openSyncDatabase } from "../db/connection";
 import { getReferenceData, setReferenceData } from "./operations";
 import { businessService } from "../adapters/services";
+import { useIsEffectivelyOnline } from "../hooks/use-infinite-list";
 const MEMBERSHIP_KEYS = {
     all: ["my-membership"],
     byBusiness: (id) => [...MEMBERSHIP_KEYS.all, id],
@@ -42,13 +43,14 @@ function useCapabilitiesPlaceholder(businessId) {
 }
 /**
  * Standard hook for both apps — businessId comes from the host's active business store.
- * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ * Offline-first: when offline, only the SQLite cache (`capabilities`) is used so
+ * nav filtering (menu/pos/orders/deliveries hidden) does not break when backend is down.
+ * When online, network refreshes the cache.
  */
 export function useBusinessCapabilities(businessId) {
-    const queryClient = useQueryClient();
-    void queryClient;
+    const isOnline = useIsEffectivelyOnline();
     const cached = useCapabilitiesPlaceholder(businessId ?? null);
-    return useQuery({
+    const query = useQuery({
         queryKey: MEMBERSHIP_KEYS.byBusiness(businessId ?? ""),
         queryFn: async () => {
             const res = (await businessService.fetchMyBusinessMembership(businessId));
@@ -64,16 +66,26 @@ export function useBusinessCapabilities(businessId) {
             catch { }
             return res;
         },
-        enabled: !!businessId,
-        staleTime: Infinity,
+        enabled: !!businessId && isOnline,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
         placeholderData: cached ?? undefined,
-        select: (data) => ({
-            role: data.data.role,
-            source: data.data.source,
-            capabilities: data.data.capabilities,
-            status: data.data.status,
-        }),
     });
+    // When offline, use the SQLite-cached membership directly so nav stays visible.
+    const raw = query.data ?? cached ?? null;
+    const selected = raw
+        ? {
+            role: raw.data.role,
+            source: raw.data.source,
+            capabilities: raw.data.capabilities,
+            status: raw.data.status,
+        }
+        : undefined;
+    return {
+        ...query,
+        data: selected,
+    };
 }
 export function useHasCapabilityFor(businessId, capability) {
     const { data } = useBusinessCapabilities(businessId);
@@ -93,6 +105,9 @@ export const CAPABILITY_BY_COMMAND = {
     "menu:update_item": "menu_manage",
     "menu:delete_item": "menu_manage",
     "menu:create_category": "menu_manage",
+    "menu:update_category": "menu_manage",
+    "menu:delete_category": "menu_manage",
+    "payment:confirm_cash": "orders_accept",
 };
 export async function hasCapabilitySync(businessId, commandType) {
     const required = CAPABILITY_BY_COMMAND[commandType];

package/dist/reference/hooks.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Reference-data React hooks — single source for both apps.
+ * Sync hooks use core connectivity/business adapters; cache reads are pure
+ * SQLite (never network). Image-query invalidation uses the shared
+ * ["cachedImage"] prefix both apps use.
+ */
+import type { ReferenceDataKey, ReferenceSyncOptions, ReferenceSyncResult } from "./types";
+export declare const REFERENCE_KEYS: {
+    all: readonly ["reference"];
+    sync: readonly ["reference", "sync"];
+    data: (key: ReferenceDataKey) => readonly ["reference", "data", ReferenceDataKey];
+};
+/**
+ * Trigger reference data synchronization when the active business changes.
+ * Does not return data; fires a background sync. Set `enabled` to false to
+ * disable automatic sync.
+ */
+export declare function useReferenceDataSync(businessId: string | undefined, options?: Omit<ReferenceSyncOptions, "businessId"> & {
+    enabled?: boolean;
+}): void;
+/** Manually trigger reference data sync. */
+export declare function useSyncReferenceData(): (options: ReferenceSyncOptions) => Promise<ReferenceSyncResult>;
+/**
+ * App-level reference sync: downloads every reference-backed dataset into
+ * the SQLite cache so the business operates fully offline. Call once from
+ * the app root/layouts. Strict reachable gate — `unknown` (cold start)
+ * must not fire sync, otherwise airplane launch hangs on versions fetch.
+ */
+export declare function useBusinessReferenceDataSync(): void;
+/**
+ * Read a reference data record from the local SQLite cache for the active
+ * business. Never hits the network.
+ */
+export declare function useReferenceData<T>(key: ReferenceDataKey): import("@tanstack/react-query").UseQueryResult<import("./types").ReferenceDataRecord<T> | null, Error>;