@teincfood/core 0.10.3 → 0.10.4

package/dist/adapters/filesystem.d.ts

@@ -21,6 +21,7 @@ export interface FileSystemAdapter {
         encoding?: string;
     }): Promise<string>;
     readAsBase64Async?(path: string): Promise<string>;
+    writeAsBase64Async?(path: string, base64: string): Promise<void>;
 }
 export declare function setFileSystemAdapter(a: FileSystemAdapter | null): void;
 export declare function getFileSystemAdapter(): FileSystemAdapter | null;

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

@@ -7,8 +7,12 @@ export declare const imageCacheService: {
         skipIfCached?: boolean;
     }): Promise<string[]>;
     pruneImageCache(urls: (string | null | undefined)[]): Promise<void>;
+    hasCachedImage?(url: string | null | undefined): Promise<boolean>;
+    cacheImageFromBase64?(url: string | null | undefined, base64: string | null | undefined): Promise<boolean>;
 };
 export declare function cacheImageBatch(urls: (string | null | undefined)[], opts?: {
     skipIfCached?: boolean;
 }): Promise<string[]>;
 export declare function pruneImageCache(urls: (string | null | undefined)[]): Promise<void>;
+export declare function hasCachedImage(url: string | null | undefined): Promise<boolean>;
+export declare function cacheImageFromBase64(url: string | null | undefined, base64: string | null | undefined): Promise<boolean>;

package/dist/adapters/image-cache.js

@@ -1,3 +1,4 @@
+import { hasCachedImage as hasCachedImageWithFileSystem, cacheImageFromBase64 as cacheImageFromBase64WithFileSystem, } from "../image-cache/service";
 /**
  * Image cache stub — no-op in core library.
  * Host apps with file-system access inject real impl via imageCacheService.
@@ -14,3 +15,14 @@ export async function cacheImageBatch(urls, opts) {
 export async function pruneImageCache(urls) {
     return imageCacheService.pruneImageCache(urls);
 }
+export async function hasCachedImage(url) {
+    if (imageCacheService.hasCachedImage)
+        return imageCacheService.hasCachedImage(url);
+    return hasCachedImageWithFileSystem(url);
+}
+export async function cacheImageFromBase64(url, base64) {
+    if (imageCacheService.cacheImageFromBase64) {
+        return imageCacheService.cacheImageFromBase64(url, base64);
+    }
+    return cacheImageFromBase64WithFileSystem(url, base64);
+}

package/dist/adapters/services.d.ts

@@ -51,6 +51,7 @@ export declare const menuService: {
 export declare const businessService: {
     fetchBusinessMembers: (_businessId: string) => Promise<unknown>;
     inviteBusinessMember: (_businessId: string, _data: Record<string, unknown>) => Promise<unknown>;
+    updateBusinessMember: (_businessId: string, _userId: string, _data: Record<string, unknown>) => Promise<unknown>;
     removeBusinessMember: (_businessId: string, _userId: string) => Promise<unknown>;
     fetchBusinessMemberInvitations: (_businessId: string) => Promise<unknown>;
     revokeBusinessMemberInvitation: (_businessId: string, _invitationId: string) => Promise<unknown>;

package/dist/adapters/services.js

@@ -92,6 +92,9 @@ export const businessService = {
     inviteBusinessMember: async (_businessId, _data) => {
         notImpl("businessService.inviteBusinessMember");
     },
+    updateBusinessMember: async (_businessId, _userId, _data) => {
+        notImpl("businessService.updateBusinessMember");
+    },
     removeBusinessMember: async (_businessId, _userId) => {
         notImpl("businessService.removeBusinessMember");
     },

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

@@ -27,6 +27,11 @@ export declare function useInviteMemberMutation(): import("@tanstack/react-query
     role?: string;
 }, unknown>;
 export declare function useRemoveMemberMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+export declare function useUpdateMemberRoleMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    userId: string;
+    role?: string;
+    status?: 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>;

package/dist/hooks/members.hooks.js

@@ -9,6 +9,7 @@ import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
 import { getAuthToken, subscribeAuth } from "../adapters/auth";
 import { businessService, rolesService, fleetService } from "../adapters/services";
 import { assertOnlineFor } from "../sync/online-gates";
+import { runOfflineCapableMutation } from "../sync/offline-capable";
 import { validateInviteInput } from "../validation/offline";
 import { notifySuccess, notifyError } from "../adapters/notify";
 import { extractApiErrorMessage } from "../utils/error";
@@ -24,6 +25,9 @@ function useIsAuthenticated() {
     return !!token;
 }
 const OFFLINE_FIRST = { retry: false, networkMode: "offlineFirst" };
+function isQueued(result) {
+    return Boolean(result && typeof result === "object" && result.status === "pending");
+}
 // ─── Keys ───
 export const MEMBER_KEYS = {
     all: ["business-members"],
@@ -64,12 +68,20 @@ export function useInviteMemberMutation() {
     const businessId = useBusinessId();
     return useMutation({
         mutationFn: (data) => {
-            assertOnlineFor("member:invite");
+            if (!businessId)
+                throw new Error("No active business");
             validateInviteInput({ email: data.email, phone: data.phone });
-            return businessService.inviteBusinessMember(businessId, data);
-        },
-        onSuccess: () => {
-            notifySuccess("Invitation sent!");
+            return runOfflineCapableMutation({
+                run: () => businessService.inviteBusinessMember(businessId, data),
+                commandType: "member:invite",
+                businessId,
+                payload: data,
+            });
+        },
+        onSuccess: (result) => {
+            notifySuccess(isQueued(result)
+                ? "Invitation queued — it will send when this device reconnects."
+                : "Invitation sent!");
             queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
             if (businessId)
                 emitReferenceChanged(businessId, ["members"]);
@@ -84,11 +96,45 @@ export function useRemoveMemberMutation() {
     const businessId = useBusinessId();
     return useMutation({
         mutationFn: (userId) => {
-            assertOnlineFor("member:manage");
-            return businessService.removeBusinessMember(businessId, userId);
+            if (!businessId)
+                throw new Error("No active business");
+            return runOfflineCapableMutation({
+                run: () => businessService.removeBusinessMember(businessId, userId),
+                commandType: "member:remove",
+                businessId,
+                entityId: userId,
+                payload: { user_id: userId },
+            });
+        },
+        onSuccess: (result) => {
+            notifySuccess(isQueued(result) ? "Member removal queued" : "Member removed");
+            queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
+            if (businessId)
+                emitReferenceChanged(businessId, ["members"]);
         },
-        onSuccess: () => {
-            notifySuccess("Member removed");
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useUpdateMemberRoleMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: ({ userId, role, status }) => {
+            if (!businessId)
+                throw new Error("No active business");
+            const payload = { ...(role ? { role } : {}), ...(status ? { status } : {}) };
+            return runOfflineCapableMutation({
+                run: () => businessService.updateBusinessMember(businessId, userId, payload),
+                commandType: "member:update",
+                businessId,
+                entityId: userId,
+                payload,
+            });
+        },
+        onSuccess: (result) => {
+            notifySuccess(isQueued(result) ? "Role change queued" : "Member role updated");
             queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
             if (businessId)
                 emitReferenceChanged(businessId, ["members"]);

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

@@ -46,6 +46,10 @@ export declare function cacheRemoteImage(url: string | null | undefined, opts?:
     skipIfCached?: boolean;
     removeOnFailure?: boolean;
 }): Promise<ImageCacheEntry | null>;
+/** True when the durable cache already has bytes for this exact URL key. */
+export declare function hasCachedImage(url: string | null | undefined): Promise<boolean>;
+/** Persist image bytes received from a LAN peer into the durable cache. */
+export declare function cacheImageFromBase64(url: string | null | undefined, base64: string | null | undefined): Promise<boolean>;
 export declare function cacheImageBatch(urls: (string | null | undefined)[], opts?: {
     skipIfCached?: boolean;
     removeOnFailure?: boolean;

package/dist/image-cache/service.js

@@ -123,6 +123,42 @@ export async function cacheRemoteImage(url, opts = {}) {
         await fs.deleteAsync(localPath, { idempotent: true }).catch(() => { });
     return { remoteUrl: url, localUri: null, etag: null, lastModified: null, cachedAt: null };
 }
+/** True when the durable cache already has bytes for this exact URL key. */
+export async function hasCachedImage(url) {
+    if (!url)
+        return false;
+    const fs = getFileSystemAdapter();
+    if (!fs)
+        return false;
+    try {
+        const info = await fs.getInfoAsync(getCachedImagePath(url));
+        return info.exists && !info.isDirectory;
+    }
+    catch {
+        return false;
+    }
+}
+/** Persist image bytes received from a LAN peer into the durable cache. */
+export async function cacheImageFromBase64(url, base64) {
+    if (!url || !base64)
+        return false;
+    const fs = getFileSystemAdapter();
+    if (!fs?.writeAsBase64Async)
+        return false;
+    try {
+        await ensureImageCacheDir();
+        const localPath = getCachedImagePath(url);
+        await fs.writeAsBase64Async(localPath, base64);
+        return true;
+    }
+    catch (error) {
+        syncLogger.warn("ImageCache", "Failed to store LAN image", {
+            url,
+            error: String(error),
+        });
+        return false;
+    }
+}
 export async function cacheImageBatch(urls, opts = {}) {
     const results = await Promise.all(urls.map((u) => cacheRemoteImage(u, opts)));
     return results.filter((r) => r !== null);

package/dist/local-node/adapters.d.ts

@@ -36,6 +36,13 @@ export interface LocalNodeClient {
     requestReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<{
         data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
     }>;
+    /** Fetch cached image bytes from a peer on a dark LAN. */
+    requestAsset?(businessId: string, url: string): Promise<{
+        url: string;
+        base64: string | null;
+        contentType?: string | null;
+        error?: string | null;
+    }>;
     publishEvent?(event: DomainEvent): Promise<void> | void;
 }
 export interface TransportAdapter {

package/dist/local-node/peer-bus.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Peer request bus.
+ *
+ * `reference/service.ts` needs to ask the LAN mesh for missed reference data
+ * and image bytes, while `local-node/service.ts` owns the live peer clients.
+ * A tiny registry avoids a module cycle between those two services.
+ */
+import type { ReferenceDataKey, ReferenceDataRecord } from "../reference/types";
+export interface LanAssetResult {
+    url: string;
+    base64: string | null;
+    contentType?: string | null;
+    error?: string | null;
+}
+type ReferenceFetcher = (businessId: string, keys: ReferenceDataKey[]) => Promise<{
+    data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
+}>;
+type AssetFetcher = (businessId: string, url: string) => Promise<LanAssetResult | null>;
+export declare function registerLocalNodePeerBus(bus: {
+    requestReference?: ReferenceFetcher;
+    requestAsset?: AssetFetcher;
+}): void;
+export declare function requestReferenceFromPeer(businessId: string, keys: ReferenceDataKey[]): Promise<{
+    data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
+} | null>;
+export declare function requestAssetFromPeer(businessId: string, url: string): Promise<LanAssetResult | null>;
+export {};

package/dist/local-node/peer-bus.js

@@ -0,0 +1,33 @@
+/**
+ * Peer request bus.
+ *
+ * `reference/service.ts` needs to ask the LAN mesh for missed reference data
+ * and image bytes, while `local-node/service.ts` owns the live peer clients.
+ * A tiny registry avoids a module cycle between those two services.
+ */
+let referenceFetcher = null;
+let assetFetcher = null;
+export function registerLocalNodePeerBus(bus) {
+    referenceFetcher = bus.requestReference ?? null;
+    assetFetcher = bus.requestAsset ?? null;
+}
+export async function requestReferenceFromPeer(businessId, keys) {
+    if (!referenceFetcher)
+        return null;
+    try {
+        return await referenceFetcher(businessId, keys);
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestAssetFromPeer(businessId, url) {
+    if (!assetFetcher)
+        return null;
+    try {
+        return await assetFetcher(businessId, url);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/local-node/service.d.ts

@@ -22,6 +22,8 @@ declare class LocalNodeServiceCore {
     /** Whether discovery scanning was successfully started. */
     private discovering;
     init(deps: LocalNodeDeps): void;
+    private requestReferenceFromPeers;
+    private requestAssetFromPeers;
     private getDeps;
     private getDeviceId;
     private runLifecycle;

package/dist/local-node/service.js

@@ -16,6 +16,7 @@ import { insertOrder } from "../db/operations";
 import { createLocalOrder, transitionLocalOrder } from "../domain/orders/service";
 import { getConnectivityState } from "../adapters/connectivity";
 import { deriveLanSecret as deriveSecretCore } from "./security";
+import { registerLocalNodePeerBus } from "./peer-bus";
 const KEEP_AWAKE_TAG = "TeincLocalNode";
 const RECONNECT_BASE = 1000;
 const RECONNECT_MAX = 30000;
@@ -54,7 +55,40 @@ class LocalNodeServiceCore {
          * discovery event; back off quietly and re-probe after the window. */
         this.mismatchBackoff = new Map();
     }
-    init(deps) { this.deps = deps; }
+    init(deps) {
+        this.deps = deps;
+        registerLocalNodePeerBus({
+            requestReference: (businessId, keys) => this.requestReferenceFromPeers(businessId, keys),
+            requestAsset: (businessId, url) => this.requestAssetFromPeers(businessId, url),
+        });
+    }
+    async requestReferenceFromPeers(businessId, keys) {
+        let lastError = null;
+        for (const peer of this.peers.values()) {
+            if (!peer.isConnected())
+                continue;
+            try {
+                return await peer.requestReferenceData(businessId, keys);
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error("No LAN peer served reference data");
+    }
+    async requestAssetFromPeers(businessId, url) {
+        for (const peer of this.peers.values()) {
+            if (!peer.isConnected() || !peer.requestAsset)
+                continue;
+            try {
+                const result = await peer.requestAsset(businessId, url);
+                if (result?.base64)
+                    return result;
+            }
+            catch { }
+        }
+        return null;
+    }
     getDeps() {
         if (!this.deps)
             throw new Error("LocalNodeService not initialised: call initLocalNodeService(deps) first");

package/dist/offline/service.d.ts

@@ -65,7 +65,7 @@ export declare function exchangeOfflineSession(args: {
 }): Promise<OfflineExchangeResult>;
 /** Read local license/member state without touching the network. */
 export declare function getOfflineSessionState(businessId?: string): Promise<OfflineSessionState>;
-export declare function verifyOfflineLogin(userId: string, pin: string): Promise<OfflineMemberCredential | null>;
+export declare function verifyOfflineLogin(userId: string, pin: string, businessId?: string): Promise<OfflineMemberCredential | null>;
 export declare function enrollMemberOnDevice(args: {
     businessId: string;
     deviceId?: string;
@@ -78,6 +78,6 @@ export declare function revokeMemberOnDevice(args: {
 }): Promise<void>;
 /** Owner action: revoke the terminal and wipe all local offline credentials. */
 export declare function removeOfflineDevice(businessId: string, reason?: string): Promise<void>;
-export declare function getStoredOfflineLicensePayload(): Promise<OfflineLicensePayload | null>;
+export declare function getStoredOfflineLicensePayload(businessId?: string): Promise<OfflineLicensePayload | null>;
 export declare function evaluateStoredOfflineLicense(businessId?: string): Promise<OfflineLicenseEvaluation>;
 export { evaluateOfflineLicense };

package/dist/offline/service.js

@@ -49,10 +49,11 @@ export async function activateOfflineDevice(args) {
     if (!verified)
         throw new Error("Activation returned an invalid offline license");
     await saveDevicePrivateKey(base64UrlEncode(keypair.privateKey));
-    await saveStoredLicense(data.license);
-    await saveStoredLicensePublicKey(data.public_key);
-    await saveStoredLicenseKeyId(data.key_id);
+    await saveStoredLicense(args.businessId, data.license);
+    await saveStoredLicensePublicKey(args.businessId, data.public_key);
+    await saveStoredLicenseKeyId(args.businessId, data.key_id);
     await createOfflineMemberCredential({
+        businessId: args.businessId,
         userId: args.member.userId,
         fullName: args.member.fullName,
         email: args.member.email,
@@ -84,9 +85,9 @@ export async function refreshOfflineLicense(businessId) {
     const verified = await verifyOfflineLicense(data.license, data.public_key, businessId);
     if (!verified)
         throw new Error("License refresh returned an invalid license");
-    await saveStoredLicense(data.license);
-    await saveStoredLicensePublicKey(data.public_key);
-    await saveStoredLicenseKeyId(data.key_id);
+    await saveStoredLicense(businessId, data.license);
+    await saveStoredLicensePublicKey(businessId, data.public_key);
+    await saveStoredLicenseKeyId(businessId, data.key_id);
     return { ...data, payload: verified };
 }
 /**
@@ -95,8 +96,8 @@ export async function refreshOfflineLicense(businessId) {
  * expired while the terminal was offline.
  */
 export async function exchangeOfflineSession(args) {
-    const token = await getStoredLicense();
-    const publicKey = await getStoredLicensePublicKey();
+    const token = await getStoredLicense(args.businessId);
+    const publicKey = await getStoredLicensePublicKey(args.businessId);
     const privateKey = await getPrivateKeyBytes();
     if (!token || !publicKey || !privateKey) {
         throw new Error("This device has no offline license");
@@ -130,19 +131,19 @@ export async function exchangeOfflineSession(args) {
     const refreshed = await verifyOfflineLicense(data.license, data.public_key, args.businessId);
     if (!refreshed)
         throw new Error("Offline exchange returned an invalid license");
-    await saveStoredLicense(data.license);
-    await saveStoredLicensePublicKey(data.public_key);
-    await saveStoredLicenseKeyId(data.key_id);
-    await markOfflineMemberLogin(args.memberId);
+    await saveStoredLicense(args.businessId, data.license);
+    await saveStoredLicensePublicKey(args.businessId, data.public_key);
+    await saveStoredLicenseKeyId(args.businessId, data.key_id);
+    await markOfflineMemberLogin(args.memberId, args.businessId);
     return { ...data, license_payload: refreshed };
 }
 /** Read local license/member state without touching the network. */
 export async function getOfflineSessionState(businessId) {
     const [token, publicKey, keyId, members] = await Promise.all([
-        getStoredLicense(),
-        getStoredLicensePublicKey(),
-        getStoredLicenseKeyId(),
-        listOfflineMembers(),
+        getStoredLicense(businessId),
+        getStoredLicensePublicKey(businessId),
+        getStoredLicenseKeyId(businessId),
+        listOfflineMembers(businessId),
     ]);
     const { payload, evaluation } = await loadAndVerifyOfflineLicense({
         token,
@@ -158,14 +159,14 @@ export async function getOfflineSessionState(businessId) {
         members,
     };
 }
-export async function verifyOfflineLogin(userId, pin) {
-    const member = await getOfflineMember(userId);
+export async function verifyOfflineLogin(userId, pin, businessId) {
+    const member = await getOfflineMember(userId, businessId);
     if (!member)
         return null;
-    const ok = await verifyOfflineMemberPin(userId, pin);
+    const ok = await verifyOfflineMemberPin(userId, pin, businessId);
     if (!ok)
         return null;
-    await markOfflineMemberLogin(userId);
+    await markOfflineMemberLogin(userId, businessId);
     return member;
 }
 export async function enrollMemberOnDevice(args) {
@@ -175,7 +176,7 @@ export async function enrollMemberOnDevice(args) {
 export async function revokeMemberOnDevice(args) {
     const deviceId = args.deviceId ?? (await getAppInstanceIdAsync());
     await getHttpClient().delete(`/businesses/${args.businessId}/devices/${encodeURIComponent(deviceId)}/members/${encodeURIComponent(args.userId)}`);
-    await removeOfflineMember(args.userId);
+    await removeOfflineMember(args.userId, args.businessId);
 }
 /** Owner action: revoke the terminal and wipe all local offline credentials. */
 export async function removeOfflineDevice(businessId, reason) {
@@ -188,10 +189,10 @@ export async function removeOfflineDevice(businessId, reason) {
             error: String(error),
         });
     }
-    await clearOfflineDevice();
+    await clearOfflineDevice(businessId);
 }
-export async function getStoredOfflineLicensePayload() {
-    const token = await getStoredLicense();
+export async function getStoredOfflineLicensePayload(businessId) {
+    const token = await getStoredLicense(businessId);
     return token ? decodeLicensePayload(token) : null;
 }
 export async function evaluateStoredOfflineLicense(businessId) {

package/dist/offline/store.d.ts

@@ -9,12 +9,28 @@
  * server password or its hash.
  */
 export declare const OFFLINE_STORAGE_KEYS: {
+    /** Business-id keyed map: { [businessId]: { token, public_key, key_id } } */
+    readonly LICENSES: "offline:licenses";
     readonly LICENSE: "offline:license";
     readonly PUBLIC_KEY: "offline:license:public_key";
     readonly KEY_ID: "offline:license:key_id";
     readonly MEMBERS: "offline:members";
     readonly DEVICE_PRIVATE_KEY: "offline:device:private_key";
 };
+export interface OfflineLicenseRecord {
+    token: string;
+    public_key: string;
+    key_id: string;
+    saved_at: string;
+}
+export declare function getStoredLicense(businessId?: string): Promise<string | null>;
+export declare function saveStoredLicense(businessId: string, token: string): Promise<void>;
+export declare function getStoredLicensePublicKey(businessId?: string): Promise<string | null>;
+export declare function saveStoredLicensePublicKey(businessId: string, publicKey: string): Promise<void>;
+export declare function getStoredLicenseKeyId(businessId?: string): Promise<string | null>;
+export declare function saveStoredLicenseKeyId(businessId: string, keyId: string): Promise<void>;
+export declare function listStoredLicenseBusinessIds(): Promise<string[]>;
+export declare function removeStoredLicense(businessId: string): Promise<void>;
 export interface OfflineSecureStorage {
     getItem(key: string): Promise<string | null>;
     setItem(key: string, value: string): Promise<void>;
@@ -24,14 +40,10 @@ export declare function setOfflineSecureStorage(storage: OfflineSecureStorage |
 export declare function getDevicePrivateKey(): Promise<string | null>;
 export declare function saveDevicePrivateKey(privateKeyB64: string): Promise<void>;
 export declare function removeDevicePrivateKey(): Promise<void>;
-export declare function getStoredLicense(): Promise<string | null>;
-export declare function saveStoredLicense(token: string): Promise<void>;
-export declare function getStoredLicensePublicKey(): Promise<string | null>;
-export declare function saveStoredLicensePublicKey(publicKey: string): Promise<void>;
-export declare function getStoredLicenseKeyId(): Promise<string | null>;
-export declare function saveStoredLicenseKeyId(keyId: string): Promise<void>;
 export interface OfflineMemberCredential {
     user_id: string;
+    /** Business this offline credential is scoped to. */
+    business_id?: string;
     full_name: string;
     email?: string | null;
     role: string;
@@ -41,13 +53,14 @@ export interface OfflineMemberCredential {
     enrolled_at: string;
     last_login_at?: string | null;
 }
-export declare function listOfflineMembers(): Promise<OfflineMemberCredential[]>;
-export declare function getOfflineMember(userId: string): Promise<OfflineMemberCredential | null>;
+export declare function listOfflineMembers(businessId?: string): Promise<OfflineMemberCredential[]>;
+export declare function getOfflineMember(userId: string, businessId?: string): Promise<OfflineMemberCredential | null>;
 export declare function saveOfflineMember(member: OfflineMemberCredential): Promise<void>;
-export declare function removeOfflineMember(userId: string): Promise<void>;
-export declare function markOfflineMemberLogin(userId: string): Promise<void>;
-export declare function clearOfflineDevice(): Promise<void>;
+export declare function removeOfflineMember(userId: string, businessId?: string): Promise<void>;
+export declare function markOfflineMemberLogin(userId: string, businessId?: string): Promise<void>;
+export declare function clearOfflineDevice(businessId?: string): Promise<void>;
 export declare function createOfflineMemberCredential(args: {
+    businessId: string;
     userId: string;
     fullName: string;
     email?: string | null;
@@ -55,4 +68,4 @@ export declare function createOfflineMemberCredential(args: {
     capabilities: string[];
     pin: string;
 }): Promise<OfflineMemberCredential>;
-export declare function verifyOfflineMemberPin(userId: string, pin: string): Promise<boolean>;
+export declare function verifyOfflineMemberPin(userId: string, pin: string, businessId?: string): Promise<boolean>;

package/dist/offline/store.js

@@ -12,12 +12,89 @@ import { getItem, removeItem, setItem } from "../adapters/kv";
 import { sha256Hex } from "../reference/entitlement-crypto";
 import { offlineRandomBytes } from "./random";
 export const OFFLINE_STORAGE_KEYS = {
+    /** Business-id keyed map: { [businessId]: { token, public_key, key_id } } */
+    LICENSES: "offline:licenses",
+    // Legacy single-license keys, retained only for migration.
     LICENSE: "offline:license",
     PUBLIC_KEY: "offline:license:public_key",
     KEY_ID: "offline:license:key_id",
     MEMBERS: "offline:members",
     DEVICE_PRIVATE_KEY: "offline:device:private_key",
 };
+async function getLicenseMap() {
+    return (await getItem(OFFLINE_STORAGE_KEYS.LICENSES)) ?? {};
+}
+async function getLicenseRecord(businessId) {
+    const map = await getLicenseMap();
+    if (businessId && map[businessId])
+        return map[businessId];
+    if (!businessId) {
+        const first = Object.values(map)[0];
+        if (first)
+            return first;
+    }
+    // Migration path from the original single-license build. Verification still
+    // checks the business id inside the signed payload, so this cannot leak a
+    // license into the wrong tenant.
+    const [token, publicKey, keyId] = await Promise.all([
+        getItem(OFFLINE_STORAGE_KEYS.LICENSE),
+        getItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY),
+        getItem(OFFLINE_STORAGE_KEYS.KEY_ID),
+    ]);
+    if (token && publicKey) {
+        return { token, public_key: publicKey, key_id: keyId ?? "", saved_at: new Date().toISOString() };
+    }
+    return null;
+}
+async function saveLicenseRecord(businessId, record) {
+    const map = await getLicenseMap();
+    map[businessId] = record;
+    await setItem(OFFLINE_STORAGE_KEYS.LICENSES, map);
+    // Drop legacy singletons once a scoped record exists.
+    await Promise.all([
+        removeItem(OFFLINE_STORAGE_KEYS.LICENSE),
+        removeItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY),
+        removeItem(OFFLINE_STORAGE_KEYS.KEY_ID),
+    ]);
+}
+export async function getStoredLicense(businessId) {
+    return (await getLicenseRecord(businessId))?.token ?? null;
+}
+export async function saveStoredLicense(businessId, token) {
+    const existing = await getLicenseRecord(businessId);
+    await saveLicenseRecord(businessId, {
+        token,
+        public_key: existing?.public_key ?? "",
+        key_id: existing?.key_id ?? "",
+        saved_at: new Date().toISOString(),
+    });
+}
+export async function getStoredLicensePublicKey(businessId) {
+    return (await getLicenseRecord(businessId))?.public_key ?? null;
+}
+export async function saveStoredLicensePublicKey(businessId, publicKey) {
+    const existing = await getLicenseRecord(businessId);
+    if (!existing)
+        throw new Error("Save the signed license before its public key");
+    await saveLicenseRecord(businessId, { ...existing, public_key: publicKey });
+}
+export async function getStoredLicenseKeyId(businessId) {
+    return (await getLicenseRecord(businessId))?.key_id ?? null;
+}
+export async function saveStoredLicenseKeyId(businessId, keyId) {
+    const existing = await getLicenseRecord(businessId);
+    if (!existing)
+        throw new Error("Save the signed license before its key id");
+    await saveLicenseRecord(businessId, { ...existing, key_id: keyId });
+}
+export async function listStoredLicenseBusinessIds() {
+    return Object.keys(await getLicenseMap());
+}
+export async function removeStoredLicense(businessId) {
+    const map = await getLicenseMap();
+    delete map[businessId];
+    await setItem(OFFLINE_STORAGE_KEYS.LICENSES, map);
+}
 let secureStorage = null;
 export function setOfflineSecureStorage(storage) {
     secureStorage = storage;
@@ -37,49 +114,51 @@ export async function saveDevicePrivateKey(privateKeyB64) {
 export async function removeDevicePrivateKey() {
     await secure().removeItem(OFFLINE_STORAGE_KEYS.DEVICE_PRIVATE_KEY);
 }
-export async function getStoredLicense() {
-    return getItem(OFFLINE_STORAGE_KEYS.LICENSE);
-}
-export async function saveStoredLicense(token) {
-    await setItem(OFFLINE_STORAGE_KEYS.LICENSE, token);
+function memberMatchesBusiness(member, businessId) {
+    if (!businessId)
+        return true;
+    // Pre-migration rows had no business_id; keep them visible until an online
+    // activation rewrites them with the correct scope.
+    return !member.business_id || member.business_id === businessId;
 }
-export async function getStoredLicensePublicKey() {
-    return getItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY);
+export async function listOfflineMembers(businessId) {
+    const members = (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
+    return members.filter((member) => memberMatchesBusiness(member, businessId));
 }
-export async function saveStoredLicensePublicKey(publicKey) {
-    await setItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY, publicKey);
-}
-export async function getStoredLicenseKeyId() {
-    return getItem(OFFLINE_STORAGE_KEYS.KEY_ID);
-}
-export async function saveStoredLicenseKeyId(keyId) {
-    await setItem(OFFLINE_STORAGE_KEYS.KEY_ID, keyId);
-}
-export async function listOfflineMembers() {
-    return (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
-}
-export async function getOfflineMember(userId) {
-    const members = await listOfflineMembers();
+export async function getOfflineMember(userId, businessId) {
+    const members = await listOfflineMembers(businessId);
     return members.find((member) => member.user_id === userId) ?? null;
 }
 export async function saveOfflineMember(member) {
-    const members = await listOfflineMembers();
-    const next = members.filter((existing) => existing.user_id !== member.user_id);
+    const all = (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
+    const next = all.filter((existing) => existing.user_id !== member.user_id ||
+        (existing.business_id ?? "") !== (member.business_id ?? ""));
     next.push(member);
     await setItem(OFFLINE_STORAGE_KEYS.MEMBERS, next);
 }
-export async function removeOfflineMember(userId) {
-    const members = await listOfflineMembers();
-    await setItem(OFFLINE_STORAGE_KEYS.MEMBERS, members.filter((member) => member.user_id !== userId));
+export async function removeOfflineMember(userId, businessId) {
+    const all = (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
+    await setItem(OFFLINE_STORAGE_KEYS.MEMBERS, all.filter((member) => {
+        if (member.user_id !== userId)
+            return true;
+        return businessId ? member.business_id !== businessId : false;
+    }));
 }
-export async function markOfflineMemberLogin(userId) {
-    const member = await getOfflineMember(userId);
+export async function markOfflineMemberLogin(userId, businessId) {
+    const member = await getOfflineMember(userId, businessId);
     if (!member)
         return;
     await saveOfflineMember({ ...member, last_login_at: new Date().toISOString() });
 }
-export async function clearOfflineDevice() {
+export async function clearOfflineDevice(businessId) {
+    if (businessId) {
+        await removeStoredLicense(businessId);
+        const all = (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
+        await setItem(OFFLINE_STORAGE_KEYS.MEMBERS, all.filter((member) => member.business_id !== businessId));
+        return;
+    }
     await Promise.all([
+        removeItem(OFFLINE_STORAGE_KEYS.LICENSES),
         removeItem(OFFLINE_STORAGE_KEYS.LICENSE),
         removeItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY),
         removeItem(OFFLINE_STORAGE_KEYS.KEY_ID),
@@ -109,6 +188,7 @@ export async function createOfflineMemberCredential(args) {
     const salt = randomHex(32);
     const member = {
         user_id: args.userId,
+        business_id: args.businessId,
         full_name: args.fullName,
         email: args.email ?? null,
         role: args.role,
@@ -121,8 +201,8 @@ export async function createOfflineMemberCredential(args) {
     await saveOfflineMember(member);
     return member;
 }
-export async function verifyOfflineMemberPin(userId, pin) {
-    const member = await getOfflineMember(userId);
+export async function verifyOfflineMemberPin(userId, pin, businessId) {
+    const member = await getOfflineMember(userId, businessId);
     if (!member)
         return false;
     if (!/^\d{6}$/.test(pin))

package/dist/reference/capabilities.js

@@ -108,6 +108,9 @@ export const CAPABILITY_BY_COMMAND = {
     "menu:update_category": "menu_manage",
     "menu:delete_category": "menu_manage",
     "payment:confirm_cash": "orders_accept",
+    "member:invite": "business_members_manage",
+    "member:update": "business_members_manage",
+    "member:remove": "business_members_manage",
 };
 export async function hasCapabilitySync(businessId, commandType) {
     const required = CAPABILITY_BY_COMMAND[commandType];

package/dist/reference/service.js

@@ -11,7 +11,8 @@ import { openSyncDatabase } from "../db/connection";
 import { syncLogger } from "../utils/sync-logger";
 import { generateUUID } from "../utils/uuid";
 import { menuService, businessService, rolesService } from "../adapters/services";
-import { cacheImageBatch, pruneImageCache } from "../adapters/image-cache";
+import { cacheImageBatch, pruneImageCache, hasCachedImage, cacheImageFromBase64, } from "../adapters/image-cache";
+import { requestReferenceFromPeer, requestAssetFromPeer } from "../local-node/peer-bus";
 import { getConnectivityState } from "../adapters/connectivity";
 import { canBusinessSync } from "../sync/sync-guard";
 import { getAuthToken } from "../adapters/auth";
@@ -123,17 +124,41 @@ class ReferenceSyncService {
         const businessId = options.businessId;
         const { isOnline, isCloudReachable } = getConnectivityState();
         if (!isOnline || isCloudReachable === "unreachable") {
-            syncLogger.debug("ReferenceSync", "Skipping sync — cloud not reachable", {
-                businessId,
-                isOnline,
-                isCloudReachable,
-            });
-            return {
+            // Dark LAN: a peer may still have the freshest reference rows and image
+            // bytes. Compare against the mesh before declaring the pass empty.
+            const keys = options.keys ?? DEFAULT_SYNC_KEYS;
+            const lanResult = {
                 synced: [],
-                skipped: options.keys ?? DEFAULT_SYNC_KEYS,
+                skipped: keys,
                 failed: [],
                 errors: {},
             };
+            try {
+                const db = await openSyncDatabase();
+                const peer = await requestReferenceFromPeer(businessId, keys);
+                if (peer?.data) {
+                    for (const key of keys) {
+                        const record = peer.data[key];
+                        if (!record)
+                            continue;
+                        const written = await writeServerReferenceData(db, businessId, key, record.payload, record.version);
+                        if (written)
+                            lanResult.synced.push(key);
+                        else
+                            lanResult.skipped.push(key);
+                    }
+                    if (lanResult.synced.length > 0) {
+                        await this.cacheReferenceImages(db, businessId, lanResult.synced);
+                    }
+                }
+            }
+            catch (error) {
+                syncLogger.debug("ReferenceSync", "LAN reference catch-up unavailable", {
+                    businessId,
+                    error: String(error),
+                });
+            }
+            return lanResult;
         }
         syncLogger.info("ReferenceSync", "Starting reference data sync", {
             businessId,
@@ -440,6 +465,21 @@ class ReferenceSyncService {
                 keys,
                 count: cachedImages.length,
             });
+            // Fully dark LAN: the cloud download cannot run, but a peer may already
+            // have the bytes in its durable image cache. Fetch only missing keys.
+            const peerConnectivity = getConnectivityState();
+            if (!peerConnectivity.isOnline || peerConnectivity.isCloudReachable === "unreachable") {
+                for (const url of urls) {
+                    if (!url || !url.startsWith("http"))
+                        continue;
+                    if (await hasCachedImage(url))
+                        continue;
+                    const asset = await requestAssetFromPeer(businessId, url);
+                    if (asset?.base64) {
+                        await cacheImageFromBase64(url, asset.base64);
+                    }
+                }
+            }
             await pruneImageCache(urls);
         }
         catch (error) {

package/dist/sync/online-gates.js

@@ -17,8 +17,6 @@ export const ONLINE_REQUIRED = {
     "order:confirm_handover": "Handover confirmation requires online",
     "chat:send": "Chat requires online",
     "notification:register": "Notifications require online",
-    "member:invite": "Member invites require online",
-    "member:manage": "Member management requires online",
     "fleet:manage": "Fleet changes require online",
     "settings:manage": "Settings changes require online",
     "kyc:submit": "KYC submission requires online",

package/dist/sync/transport-rest.js

@@ -5,7 +5,7 @@
  * resulting domain events. This transport is used when the cloud API is
  * reachable.
  */
-import { sellerService, kioskService, menuService } from "../adapters/services";
+import { sellerService, kioskService, menuService, businessService } from "../adapters/services";
 import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
 import { createLocalOrder, transitionLocalOrder } from "../domain/orders/service";
@@ -130,6 +130,24 @@ export class RestTransport {
             case "payment:confirm_cash": {
                 return this.executeOrderTransition(command, "confirm_cash", timestamp, () => sellerService.confirmCashPayment(entity_id), "payment.completed");
             }
+            case "member:invite": {
+                const response = (await businessService.inviteBusinessMember(business_id, (payload ?? {})));
+                const data = (response?.data ?? {});
+                return this.wrapResponse("member.invited", data, data.id ?? command.command_id, timestamp, command);
+            }
+            case "member:update": {
+                if (!entity_id)
+                    throw new Error("member:update requires entity_id");
+                const response = (await businessService.updateBusinessMember(business_id, entity_id, (payload ?? {})));
+                const data = (response?.data ?? {});
+                return this.wrapResponse("member.updated", data, entity_id, timestamp, command);
+            }
+            case "member:remove": {
+                if (!entity_id)
+                    throw new Error("member:remove requires entity_id");
+                await businessService.removeBusinessMember(business_id, entity_id);
+                return this.wrapResponse("member.removed", { user_id: entity_id, status: "removed" }, entity_id, timestamp, command);
+            }
             default:
                 throw new Error(`RestTransport: unsupported command type ${command_type}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",