@teincfood/core 0.10.3 → 0.10.5

package/dist/adapters/devices.d.ts

@@ -2,6 +2,15 @@
  * Devices service — stable per-device UUID for DD lease.
  * Persists via KV sync so DD stays same for life of device (until wipe).
  */
+export interface DeviceMetadata {
+    deviceName?: string | null;
+    platform?: string | null;
+    osVersion?: string | null;
+    appVersion?: string | null;
+}
+/** Host apps inject OS/device details so licenses and admin dashboards can identify terminals. */
+export declare function setDeviceMetadataProvider(provider: (() => Promise<DeviceMetadata> | DeviceMetadata) | null): void;
+export declare function getDeviceMetadata(): Promise<DeviceMetadata>;
 export declare function setAppInstanceId(id: string): void;
 export declare function getAppInstanceId(): string;
 export declare function getAppInstanceIdAsync(): Promise<string>;

package/dist/adapters/devices.js

@@ -6,6 +6,21 @@ import { getItemSync, setItemSync, getItem, setItem } from "./kv";
 import { generateUUID } from "../utils/uuid";
 let appInstanceId = null;
 const APP_ID_KEY = "teinc_app_instance_id";
+let deviceMetadataProvider = null;
+/** Host apps inject OS/device details so licenses and admin dashboards can identify terminals. */
+export function setDeviceMetadataProvider(provider) {
+    deviceMetadataProvider = provider;
+}
+export async function getDeviceMetadata() {
+    if (!deviceMetadataProvider)
+        return {};
+    try {
+        return await deviceMetadataProvider();
+    }
+    catch {
+        return {};
+    }
+}
 // For Tauri desktop, try to restore from localStorage synchronously at import to avoid async race generating a new UUID on every cargo tauri dev restart
 try {
     if (typeof localStorage !== "undefined") {

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,8 @@ 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 { removeOfflineMember, updateOfflineMemberRole } from "../offline/store";
 import { validateInviteInput } from "../validation/offline";
 import { notifySuccess, notifyError } from "../adapters/notify";
 import { extractApiErrorMessage } from "../utils/error";
@@ -24,6 +26,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 +69,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 +97,53 @@ 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: async (result, userId) => {
+            // Revoke local offline access immediately, even when the server command
+            // is queued. Otherwise a removed member can still unlock this terminal.
+            if (businessId) {
+                await removeOfflineMember(userId, businessId).catch(() => undefined);
+            }
+            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: async (result, variables) => {
+            if (businessId && variables.role) {
+                await updateOfflineMemberRole(variables.userId, businessId, variables.role).catch(() => undefined);
+            }
+            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

@@ -50,6 +50,9 @@ export declare function activateOfflineDevice(args: {
     pin: string;
     appInstanceId?: string;
     platform?: string;
+    deviceName?: string;
+    osVersion?: string;
+    appVersion?: string;
 }): Promise<OfflineActivationResult>;
 /** Refresh the signed license while online using the normal access token. */
 export declare function refreshOfflineLicense(businessId: string): Promise<OfflineActivationResult>;
@@ -65,7 +68,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 +81,16 @@ 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>;
+/**
+ * Best-effort presence heartbeat. Updates the admin dashboard's last-seen and
+ * online state; never throws into app startup or sync loops.
+ */
+export declare function sendOfflineDeviceHeartbeat(businessId: string, overrides?: {
+    deviceName?: string;
+    platform?: string;
+    osVersion?: string;
+    appVersion?: string;
+}): Promise<void>;
+export declare function getStoredOfflineLicensePayload(businessId?: string): Promise<OfflineLicensePayload | null>;
 export declare function evaluateStoredOfflineLicense(businessId?: string): Promise<OfflineLicenseEvaluation>;
 export { evaluateOfflineLicense };

package/dist/offline/service.js

@@ -5,9 +5,10 @@
  * verify the signed license, unlock enrolled members locally, and only needs
  * the network to exchange the device challenge for fresh session tokens.
  */
-import { getAppInstanceIdAsync } from "../adapters/devices";
+import { getAppInstanceIdAsync, getDeviceMetadata } from "../adapters/devices";
 import { getHttpClient } from "../adapters/http";
 import { getAuthToken } from "../adapters/auth";
+import { getConnectivityState } from "../adapters/connectivity";
 import { syncLogger } from "../utils/sync-logger";
 import { offlineRandomBytes } from "./random";
 import { base64UrlDecode, base64UrlEncode, canonicalDeviceChallenge, decodeLicensePayload, evaluateOfflineLicense, generateOfflineDeviceKeypair, loadAndVerifyOfflineLicense, newOfflineNonce, signDeviceChallenge, verifyOfflineLicense, } from "./license";
@@ -35,11 +36,15 @@ export async function activateOfflineDevice(args) {
     if (!getAuthToken())
         throw new Error("Sign in online before activating this device");
     const deviceId = args.appInstanceId ?? (await getAppInstanceIdAsync());
+    const metadata = await getDeviceMetadata();
     const keypair = await generateOfflineDeviceKeypair(randomBytes);
     const response = await getHttpClient().post(`/businesses/${args.businessId}/devices/${encodeURIComponent(deviceId)}/activate`, {
         device_public_key: keypair.publicKeyB64,
         app_instance_id: deviceId,
-        platform: args.platform ?? "unknown",
+        platform: args.platform ?? metadata.platform ?? "unknown",
+        device_name: args.deviceName ?? metadata.deviceName ?? undefined,
+        os_version: args.osVersion ?? metadata.osVersion ?? undefined,
+        app_version: args.appVersion ?? metadata.appVersion ?? undefined,
     });
     const data = response.data.data;
     if (!data?.license || !data.public_key) {
@@ -49,10 +54,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 +90,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 +101,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 +136,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 +164,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 +181,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 +194,34 @@ export async function removeOfflineDevice(businessId, reason) {
             error: String(error),
         });
     }
-    await clearOfflineDevice();
+    await clearOfflineDevice(businessId);
+}
+/**
+ * Best-effort presence heartbeat. Updates the admin dashboard's last-seen and
+ * online state; never throws into app startup or sync loops.
+ */
+export async function sendOfflineDeviceHeartbeat(businessId, overrides = {}) {
+    if (!getAuthToken())
+        return;
+    const connectivity = getConnectivityState();
+    if (!connectivity.isOnline || connectivity.isCloudReachable === "unreachable")
+        return;
+    try {
+        const deviceId = await getAppInstanceIdAsync();
+        const metadata = await getDeviceMetadata();
+        await getHttpClient().patch(`/businesses/${businessId}/devices/${encodeURIComponent(deviceId)}/heartbeat`, {
+            device_name: overrides.deviceName ?? metadata.deviceName ?? undefined,
+            platform: overrides.platform ?? metadata.platform ?? undefined,
+            os_version: overrides.osVersion ?? metadata.osVersion ?? undefined,
+            app_version: overrides.appVersion ?? metadata.appVersion ?? undefined,
+        });
+    }
+    catch (error) {
+        syncLogger.debug("OfflineAuth", "Device heartbeat failed", { error: String(error) });
+    }
 }
-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;
@@ -40,14 +52,17 @@ export interface OfflineMemberCredential {
     pin_hash: string;
     enrolled_at: string;
     last_login_at?: string | null;
+    failed_attempts?: number;
+    locked_until?: 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 +70,14 @@ export declare function createOfflineMemberCredential(args: {
     capabilities: string[];
     pin: string;
 }): Promise<OfflineMemberCredential>;
-export declare function verifyOfflineMemberPin(userId: string, pin: string): Promise<boolean>;
+export declare const OFFLINE_PIN_MAX_ATTEMPTS = 5;
+export interface OfflinePinLockState {
+    failedAttempts: number;
+    lockedUntil: string | null;
+    locked: boolean;
+    remainingAttempts: number;
+}
+export declare function getOfflinePinLockState(userId: string, businessId?: string): Promise<OfflinePinLockState>;
+export declare function verifyOfflineMemberPin(userId: string, pin: string, businessId?: string): Promise<boolean>;
+/** Apply an offline role change to the local credential immediately. */
+export declare function updateOfflineMemberRole(userId: string, businessId: string, role: string, capabilities?: string[]): Promise<void>;

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);
+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 saveStoredLicense(token) {
-    await setItem(OFFLINE_STORAGE_KEYS.LICENSE, token);
+export async function listOfflineMembers(businessId) {
+    const members = (await getItem(OFFLINE_STORAGE_KEYS.MEMBERS)) ?? [];
+    return members.filter((member) => memberMatchesBusiness(member, businessId));
 }
-export async function getStoredLicensePublicKey() {
-    return getItem(OFFLINE_STORAGE_KEYS.PUBLIC_KEY);
-}
-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,18 +201,68 @@ export async function createOfflineMemberCredential(args) {
     await saveOfflineMember(member);
     return member;
 }
-export async function verifyOfflineMemberPin(userId, pin) {
-    const member = await getOfflineMember(userId);
+export const OFFLINE_PIN_MAX_ATTEMPTS = 5;
+export async function getOfflinePinLockState(userId, businessId) {
+    const member = await getOfflineMember(userId, businessId);
+    const failedAttempts = member?.failed_attempts ?? 0;
+    const lockedUntil = member?.locked_until ?? null;
+    const locked = Boolean(lockedUntil && new Date(lockedUntil).getTime() > Date.now());
+    return {
+        failedAttempts,
+        lockedUntil,
+        locked,
+        remainingAttempts: Math.max(OFFLINE_PIN_MAX_ATTEMPTS - failedAttempts, 0),
+    };
+}
+export async function verifyOfflineMemberPin(userId, pin, businessId) {
+    const member = await getOfflineMember(userId, businessId);
     if (!member)
         return false;
-    if (!/^\d{6}$/.test(pin))
+    if (member.locked_until && new Date(member.locked_until).getTime() > Date.now()) {
         return false;
+    }
+    if (!/^\d{6}$/.test(pin)) {
+        await recordFailedPinAttempt(member);
+        return false;
+    }
     const candidate = await hashPin(pin, member.pin_salt);
-    if (candidate.length !== member.pin_hash.length)
+    if (candidate.length !== member.pin_hash.length) {
+        await recordFailedPinAttempt(member);
         return false;
+    }
     let diff = 0;
     for (let i = 0; i < candidate.length; i++) {
         diff |= candidate.charCodeAt(i) ^ member.pin_hash.charCodeAt(i);
     }
-    return diff === 0;
+    if (diff === 0) {
+        if ((member.failed_attempts ?? 0) > 0 || member.locked_until) {
+            await saveOfflineMember({ ...member, failed_attempts: 0, locked_until: null });
+        }
+        return true;
+    }
+    await recordFailedPinAttempt(member);
+    return false;
+}
+async function recordFailedPinAttempt(member) {
+    const attempts = (member.failed_attempts ?? 0) + 1;
+    const now = Date.now();
+    const lockMs = attempts >= OFFLINE_PIN_MAX_ATTEMPTS
+        ? Math.min(15 * 60000, 60000 * 2 ** (attempts - OFFLINE_PIN_MAX_ATTEMPTS))
+        : 0;
+    await saveOfflineMember({
+        ...member,
+        failed_attempts: attempts,
+        locked_until: lockMs > 0 ? new Date(now + lockMs).toISOString() : null,
+    });
+}
+/** Apply an offline role change to the local credential immediately. */
+export async function updateOfflineMemberRole(userId, businessId, role, capabilities) {
+    const member = await getOfflineMember(userId, businessId);
+    if (!member)
+        return;
+    await saveOfflineMember({
+        ...member,
+        role,
+        ...(capabilities ? { capabilities } : {}),
+    });
 }

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.5",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",