@teincfood/core 0.7.9 → 0.8.1

package/dist/realtime/useEventsConnection.js

@@ -3,6 +3,7 @@ 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);
 }
@@ -10,6 +11,10 @@ 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.
@@ -17,12 +22,16 @@ export function useEventsConnection() {
     // 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)
+        if (!userId || !online)
             return;
         const disconnect = eventsService.connect(userId, activeBusinessId);
         return () => disconnect();
-    }, [userId, activeBusinessId]);
+    }, [userId, activeBusinessId, online]);
 }
 function deriveUserId() {
     try {

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,8 @@ 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) {

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>;

package/dist/reference/hooks.js

@@ -0,0 +1,124 @@
+/**
+ * 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 { useEffect, useCallback } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+import { openSyncDatabase } from "../db/connection";
+import { referenceSyncService } from "./service";
+import { getReferenceData } from "./operations";
+export const REFERENCE_KEYS = {
+    all: ["reference"],
+    sync: ["reference", "sync"],
+    data: (key) => ["reference", "data", key],
+};
+function useActiveBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+function useConnectivitySnapshot() {
+    return useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+}
+/**
+ * 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 function useReferenceDataSync(businessId, options = {}) {
+    const { enabled = true, ...syncOptions } = options;
+    useEffect(() => {
+        if (!enabled || !businessId)
+            return;
+        let cancelled = false;
+        referenceSyncService
+            .sync({ businessId, ...syncOptions })
+            .then((result) => {
+            if (cancelled)
+                return;
+            if (result.failed.length > 0) {
+                try {
+                    console.debug("[ReferenceSync] failed keys (non-fatal):", result.failed);
+                }
+                catch { }
+            }
+        })
+            .catch(() => {
+            if (cancelled)
+                return;
+        });
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [businessId, enabled, JSON.stringify(syncOptions)]);
+}
+/** Manually trigger reference data sync. */
+export function useSyncReferenceData() {
+    return useCallback(async (options) => {
+        return referenceSyncService.sync(options);
+    }, []);
+}
+/**
+ * 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 function useBusinessReferenceDataSync() {
+    const businessId = useActiveBusinessId();
+    const connectivity = useConnectivitySnapshot();
+    const queryClient = useQueryClient();
+    const isOnline = connectivity.isOnline;
+    const isCloudReachable = connectivity.isCloudReachable;
+    useEffect(() => {
+        if (!businessId || !isOnline || isCloudReachable !== "reachable")
+            return;
+        let cancelled = false;
+        referenceSyncService
+            .sync({ businessId })
+            .then((result) => {
+            if (cancelled)
+                return;
+            try {
+                void queryClient.invalidateQueries({ queryKey: ["cachedImage"] });
+            }
+            catch { }
+            if (result.failed.length > 0) {
+                try {
+                    console.debug("[ReferenceSync] failed keys (non-fatal):", result.failed);
+                }
+                catch { }
+            }
+        })
+            .catch(() => {
+            if (cancelled)
+                return;
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [businessId, isOnline, isCloudReachable, queryClient]);
+}
+/**
+ * Read a reference data record from the local SQLite cache for the active
+ * business. Never hits the network.
+ */
+export function useReferenceData(key) {
+    const businessId = useActiveBusinessId();
+    return useQuery({
+        queryKey: [...REFERENCE_KEYS.data(key), businessId],
+        queryFn: async () => {
+            if (!businessId)
+                return null;
+            const db = await openSyncDatabase();
+            return getReferenceData(db, businessId, key);
+        },
+        staleTime: Infinity,
+        enabled: !!businessId,
+    });
+}

package/dist/reference/menu-apply.d.ts

@@ -0,0 +1,29 @@
+import type { ReferenceDataKey } from "./types";
+import type { Command } from "../sync/types";
+export declare const MENU_ITEM_KEY: ReferenceDataKey;
+export declare const MENU_CATEGORY_KEY: ReferenceDataKey;
+/**
+ * Apply a menu:* command to the local reference cache. Returns affected keys
+ * (for reference_data.changed fan-out) and whether anything was written.
+ * Idempotent by entity id: re-applying the same command converges.
+ */
+export declare function applyMenuCommandLocal(businessId: string, command: Pick<Command, "command_type" | "entity_id" | "command_id" | "payload">): Promise<{
+    keys: ReferenceDataKey[];
+    applied: boolean;
+}>;
+/**
+ * Revert an optimistic menu write after a definitive backend rejection:
+ * restores the stashed prior record, or deletes the row for creates.
+ * Peers converge via reference_fetch/pull on the next sync.
+ */
+export declare function revertMenuCommand(businessId: string, commandType: string, entityId: string): Promise<boolean>;
+/** Keys whose cache a menu command affects (for fan-out without applying). */
+export declare function menuCommandKeys(commandType: string): ReferenceDataKey[];
+/**
+ * One-time janitor: remove cached menu rows that are not backend-shaped
+ * MenuItems (written by older builds that cached raw wire payloads). This is
+ * explicit removal of invalid data — never translation. The outbox remains
+ * the source of truth: queued creates replay to the backend and the next
+ * pull restores canonical rows. Returns the purge count for logging.
+ */
+export declare function purgeNonCanonicalMenuCache(businessId: string): Promise<number>;

package/dist/reference/menu-apply.js

@@ -0,0 +1,289 @@
+/**
+ * Local application of menu commands to the durable reference cache.
+ *
+ * Used by (a) handleNodeCommand when this device executes a peer's menu
+ * command over LAN, and (b) the engine queue branch for optimistic local
+ * apply while fully offline. Shapes mirror the cloud fetchers
+ * (reference/service fetchFallback): menu:items payload {data:[...]},
+ * menu:categories payload {data:[...]} (or bare array — tolerated).
+ *
+ * Versions are intentionally left untouched: optimistic/LAN applies converge
+ * peers via explicit reference_data.changed events + reference_fetch (which
+ * serve payloads directly, no version compare). Real versions come from the
+ * backend when the command replays through the cloud path.
+ */
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData, setReferenceData } from "./operations";
+import { syncLogger } from "../utils/sync-logger";
+import { generateUUID } from "../utils/uuid";
+import { hlcToString, tickHLC, hlcFromString } from "../utils/hlc";
+import { getAppInstanceId } from "../adapters/devices";
+export const MENU_ITEM_KEY = "menu:items";
+export const MENU_CATEGORY_KEY = "menu:categories";
+function asArray(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    const data = payload?.data;
+    return Array.isArray(data) ? data : [];
+}
+function withArray(payload, arr) {
+    if (Array.isArray(payload))
+        return arr;
+    if (payload && typeof payload === "object")
+        return { ...payload, data: arr };
+    return { data: arr };
+}
+/**
+ * Extract the caller-built cache record from a menu command payload. The
+ * reference cache holds backend-shaped records ONLY (MenuItem / MenuCategory
+ * exactly as the serializer returns them) — never wire payloads. Callers
+ * build the record alongside the wire payload; core performs no translation.
+ * A command without a record writes nothing (cloud convergence fills the
+ * cache on the next pull).
+ */
+function cacheRecord(payload) {
+    const rec = payload.cacheRecord;
+    if (!rec || typeof rec !== "object" || Array.isArray(rec))
+        return null;
+    return rec;
+}
+async function patchKey(businessId, key, patch) {
+    try {
+        const db = await openSyncDatabase();
+        const rec = await getReferenceData(db, businessId, key);
+        // Seed empty row if first-ever offline create before any pull.
+        if (!rec) {
+            const next = patch([]);
+            const hlc = hlcToString(tickHLC(Date.now(), null, getAppInstanceId()));
+            await setReferenceData(db, businessId, {
+                key,
+                version: hlc,
+                payload: withArray({ data: [] }, next),
+                downloadedAt: new Date().toISOString(),
+                lastEventId: `evt_${hlc}`,
+                lastHlc: hlc,
+            });
+            return true;
+        }
+        const next = patch(asArray(rec.payload));
+        const hlc = hlcToString(tickHLC(Date.now(), hlcFromString(rec.lastHlc ?? rec.version) ?? null, getAppInstanceId()));
+        await setReferenceData(db, businessId, {
+            key,
+            version: hlc,
+            payload: withArray(rec.payload, next),
+            downloadedAt: new Date().toISOString(),
+            lastEventId: `evt_${hlc}`,
+            lastHlc: hlc,
+        });
+        return true;
+    }
+    catch (e) {
+        syncLogger.debug("MenuApply", "local menu patch failed", { businessId, key, err: String(e) });
+        return false;
+    }
+}
+/**
+ * Apply a menu:* command to the local reference cache. Returns affected keys
+ * (for reference_data.changed fan-out) and whether anything was written.
+ * Idempotent by entity id: re-applying the same command converges.
+ */
+export async function applyMenuCommandLocal(businessId, command) {
+    const payload = (command.payload ?? {});
+    const idOf = (v) => (typeof v === "string" && v ? v : null);
+    switch (command.command_type) {
+        case "menu:create_item": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id) ?? generateUUID();
+            const record = cacheRecord(payload);
+            if (!record) {
+                syncLogger.debug("MenuApply", "create_item without cacheRecord — skipping cache write", { businessId, id: command.entity_id });
+                return { keys: [MENU_ITEM_KEY], applied: false };
+            }
+            const item = { ...record, id };
+            const applied = await patchKey(businessId, MENU_ITEM_KEY, (arr) => {
+                stashPrior(arr, businessId, id);
+                return arr.some((o) => String(o.id) === id) ? arr.map((o) => (String(o.id) === id ? item : o)) : [...arr, item];
+            });
+            return { keys: [MENU_ITEM_KEY], applied };
+        }
+        case "menu:update_item": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id) ?? idOf(payload.item_id);
+            if (!id)
+                return { keys: [MENU_ITEM_KEY], applied: false };
+            const record = cacheRecord(payload);
+            if (!record) {
+                syncLogger.debug("MenuApply", "update_item without cacheRecord — skipping cache write", { businessId, id });
+                return { keys: [MENU_ITEM_KEY], applied: false };
+            }
+            const applied = await patchKey(businessId, MENU_ITEM_KEY, (arr) => {
+                stashPrior(arr, businessId, id);
+                return arr.map((o) => (String(o.id) === id ? { ...record, id } : o));
+            });
+            return { keys: [MENU_ITEM_KEY], applied };
+        }
+        case "menu:delete_item": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id);
+            if (!id)
+                return { keys: [MENU_ITEM_KEY], applied: false };
+            const applied = await patchKey(businessId, MENU_ITEM_KEY, (arr) => arr.filter((o) => String(o.id) !== id));
+            return { keys: [MENU_ITEM_KEY], applied };
+        }
+        case "menu:create_category": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id) ?? generateUUID();
+            const record = cacheRecord(payload);
+            if (!record) {
+                syncLogger.debug("MenuApply", "create_category without cacheRecord — skipping cache write", { businessId });
+                return { keys: [MENU_CATEGORY_KEY], applied: false };
+            }
+            const cat = { ...record, id };
+            const applied = await patchKey(businessId, MENU_CATEGORY_KEY, (arr) => {
+                stashPrior(arr, businessId, id);
+                return arr.some((o) => String(o.id) === id) ? arr.map((o) => (String(o.id) === id ? cat : o)) : [...arr, cat];
+            });
+            return { keys: [MENU_CATEGORY_KEY], applied };
+        }
+        case "menu:update_category": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id) ?? idOf(payload.category_id);
+            if (!id)
+                return { keys: [MENU_CATEGORY_KEY], applied: false };
+            const record = cacheRecord(payload);
+            if (!record) {
+                syncLogger.debug("MenuApply", "update_category without cacheRecord — skipping cache write", { businessId, id });
+                return { keys: [MENU_CATEGORY_KEY], applied: false };
+            }
+            const applied = await patchKey(businessId, MENU_CATEGORY_KEY, (arr) => {
+                stashPrior(arr, businessId, id);
+                return arr.map((o) => (String(o.id) === id ? { ...record, id } : o));
+            });
+            return { keys: [MENU_CATEGORY_KEY], applied };
+        }
+        case "menu:delete_category": {
+            const id = idOf(command.entity_id) ?? idOf(payload.id) ?? idOf(payload.category_id);
+            if (!id)
+                return { keys: [MENU_CATEGORY_KEY], applied: false };
+            const applied = await patchKey(businessId, MENU_CATEGORY_KEY, (arr) => arr.filter((o) => String(o.id) !== id));
+            return { keys: [MENU_CATEGORY_KEY], applied };
+        }
+        default:
+            return { keys: [], applied: false };
+    }
+}
+/**
+ * Prior-record stash for toast-and-revert: before overwriting a cached row,
+ * the previous record is kept in memory so a backend rejection can restore
+ * it. Creates stash a tombstone (revert deletes the row).
+ */
+const priorRecords = new Map();
+function stashPrior(arr, businessId, id) {
+    try {
+        const prev = arr.find((o) => String(o.id) === id);
+        priorRecords.set(`${businessId}:${id}`, prev ? { ...prev } : null);
+    }
+    catch { }
+}
+/**
+ * Revert an optimistic menu write after a definitive backend rejection:
+ * restores the stashed prior record, or deletes the row for creates.
+ * Peers converge via reference_fetch/pull on the next sync.
+ */
+export async function revertMenuCommand(businessId, commandType, entityId) {
+    const key = `${businessId}:${entityId}`;
+    try {
+        if (commandType === "menu:create_item") {
+            const applied = await patchKey(businessId, MENU_ITEM_KEY, (arr) => arr.filter((o) => String(o.id) !== entityId));
+            priorRecords.delete(key);
+            return applied;
+        }
+        if (commandType === "menu:update_item") {
+            const prior = priorRecords.get(key);
+            priorRecords.delete(key);
+            if (prior === undefined)
+                return false;
+            const applied = await patchKey(businessId, MENU_ITEM_KEY, (arr) => {
+                if (prior === null)
+                    return arr.filter((o) => String(o.id) !== entityId);
+                return arr.some((o) => String(o.id) === entityId)
+                    ? arr.map((o) => (String(o.id) === entityId ? { ...prior, id: entityId } : o))
+                    : [...arr, { ...prior, id: entityId }];
+            });
+            return applied;
+        }
+        if (commandType === "menu:create_category") {
+            const applied = await patchKey(businessId, MENU_CATEGORY_KEY, (arr) => arr.filter((o) => String(o.id) !== entityId));
+            priorRecords.delete(key);
+            return applied;
+        }
+        if (commandType === "menu:update_category") {
+            const prior = priorRecords.get(key);
+            priorRecords.delete(key);
+            if (prior === undefined)
+                return false;
+            const applied = await patchKey(businessId, MENU_CATEGORY_KEY, (arr) => {
+                if (prior === null)
+                    return arr.filter((o) => String(o.id) !== entityId);
+                return arr.some((o) => String(o.id) === entityId)
+                    ? arr.map((o) => (String(o.id) === entityId ? { ...prior, id: entityId } : o))
+                    : [...arr, { ...prior, id: entityId }];
+            });
+            return applied;
+        }
+    }
+    catch { }
+    return false;
+}
+/** Keys whose cache a menu command affects (for fan-out without applying). */
+export function menuCommandKeys(commandType) {
+    if (commandType.startsWith("menu:") && commandType.includes("categor"))
+        return [MENU_CATEGORY_KEY];
+    if (commandType.startsWith("menu:"))
+        return [MENU_ITEM_KEY];
+    return [];
+}
+function isCanonicalMenuItem(o) {
+    if (!o || typeof o !== "object")
+        return false;
+    const r = o;
+    const bp = r.basePrice;
+    return (typeof r.id === "string" &&
+        typeof r.name === "string" &&
+        !!bp &&
+        typeof bp.amountMinor === "number" &&
+        typeof bp.currencyCode === "string" &&
+        Array.isArray(r.variants) &&
+        Array.isArray(r.extras) &&
+        Array.isArray(r.dietary_tags));
+}
+/**
+ * One-time janitor: remove cached menu rows that are not backend-shaped
+ * MenuItems (written by older builds that cached raw wire payloads). This is
+ * explicit removal of invalid data — never translation. The outbox remains
+ * the source of truth: queued creates replay to the backend and the next
+ * pull restores canonical rows. Returns the purge count for logging.
+ */
+export async function purgeNonCanonicalMenuCache(businessId) {
+    try {
+        const db = await openSyncDatabase();
+        const rec = await getReferenceData(db, businessId, MENU_ITEM_KEY);
+        if (!rec)
+            return 0;
+        const arr = asArray(rec.payload);
+        const kept = arr.filter(isCanonicalMenuItem);
+        const purged = arr.length - kept.length;
+        if (purged === 0)
+            return 0;
+        const hlc = hlcToString(tickHLC(Date.now(), hlcFromString(rec.lastHlc ?? rec.version) ?? null, getAppInstanceId()));
+        await setReferenceData(db, businessId, {
+            key: MENU_ITEM_KEY,
+            version: hlc,
+            payload: withArray(rec.payload, kept),
+            downloadedAt: new Date().toISOString(),
+            lastEventId: `evt_${hlc}`,
+            lastHlc: hlc,
+        });
+        syncLogger.warn("MenuApply", "purged non-canonical cached menu rows", { businessId, purged, kept: kept.length });
+        return purged;
+    }
+    catch (e) {
+        syncLogger.debug("MenuApply", "menu cache purge failed", { businessId, err: String(e) });
+        return 0;
+    }
+}