@teincfood/core 0.7.9 → 0.8.0

package/README.md

@@ -2,15 +2,18 @@
 
 TeincFood shared offline-first core — single source of truth for mobile (`TeincFoodBusiness`) and desktop (`TeincFoodDesktop`).
 
-## What lives here (v0.1.0 backbone)
+Current: `0.7.31`. UI → hooks → repositories → core → SQLite → SyncEngine (cloud → LAN mesh → queue) → reconciliation → UI.
+
+## What lives here
 
 - `types/api/*` — snake_case API contracts matching backend
-- `utils/*` — currency, error, format, uuid, order-number (async), etc.
-- `sync/*` — engine, command-queue, transports, routing-policy, pending-orders
+- `utils/*` — currency, error, format, uuid, order-number (DD-RRR-CCC), order-transitions, etc.
+- `sync/*` — engine, command-queue, transports (`rest`, `local_node`), pending-orders, order-snapshots, reconciliation
 - `db/*` — migrations + operations (driver-agnostic, takes a `SqliteDriver`)
-- `reference/*` — versioned reference-data cache
-- `repositories/*` — order/pos repositories
-- `adapters/*` — platform seams (KV, SQLite, HTTP, etc.)
+- `reference/*` — versioned reference-data cache (per-key HLC LWW)
+- `repositories/*` — order/pos repositories (explicit verbs, no `order.update`)
+- `local-node/*` — **LAN mesh**: lib-owned crypto/protocol/orchestration (`docs/MESH.md`)
+- `adapters/*` — platform seams (KV, SQLite, HTTP, local-node, connectivity, devices, auth, business, …)
 
 ## Adapters
 
@@ -18,27 +21,29 @@ Apps supply platform adapters via `createTeincCore({ storage, db, http, ... })`:
 
 - `KVStorage` — async `getItem/setItem/removeItem` (MMKV-wrapped on mobile, `plugin-store` on desktop)
 - `SqliteDriver` — `execAsync/runAsync/getFirstAsync/getAllAsync/withTransactionAsync`
-- `HttpClient` — axios instance with auth interceptors (token plumbing stays app-side)
-- `LanTransport` — `{ isAvailable(), execute(command) }`
+- `HttpClient` — axios/fetch instance with auth interceptors (token plumbing stays app-side)
+- `LocalNodeDeps` — `transport {createServer, createClient}`, `discovery {startPublishing, startScanning, ...}`, `getAuth/getBusiness/getDeviceId`. Core derives the LAN secret and owns the mesh lifecycle; apps only provide sockets/mDNS/TLS primitives.
 
-## Usage
+## LAN mesh
 
-```ts
-import { createTeincCore } from "@teincfood/core";
-const core = createTeincCore({ storage, db, http });
-```
+No election: every `isLocalNodeEnabled` device is server + client. Spec: `docs/MESH.md`.
+Two-process harness (real mDNS + TLS, no apps): `scripts/node-mesh/README.md`.
 
-Apps re-export types via `export * from "@teincfood/core"` barrels to avoid churn.
+## Docs
 
-## Publishing
+- `docs/MESH.md` — LAN mesh, single source of truth (crypto, wire protocol, lifecycle, order flow)
+- `docs/OFFLINE_FIRST_STRATEGY.md` — offline-first lifecycles (offline→online, Phoenix, mesh)
+- `docs/CORE_ARCHITECTURE.md` — module map and responsibilities
+- `docs/AUDIT.md` — historical `0.7.10` pre-implementation snapshot (superseded where it conflicts with `MESH.md`)
+
+## Checks
 
 ```bash
-yarn build
-npm publish --access public
+npx tsc --noEmit        # 0 errors
+npm test                # 101/101 (mesh + security vectors + sync)
 ```
 
-## Roadmap
+## Publishing
 
-- v0.2 services/stores/hooks
-- v0.3 LAN protocol + orchestrator + restart/diagnostics
-- v0.4 phoenix/events
+Apps consume the packed tarball (`teincfood-core-<version>.tgz` refreshed into
+`TeincFoodBusiness`/`TeincFoodDesktop`) or `npm publish --access public`.

package/dist/adapters/auth.d.ts

@@ -11,5 +11,13 @@ export declare const useAuthStore: {
         user: AuthUser | null;
     };
 };
+export declare function subscribeAuth(listener: () => void): () => void;
 export declare function setAuthProvider(fn: () => string | null): void;
+export declare function setAuthRefreshProvider(fn: () => string | null): void;
+export declare function setAuthTokensProvider(fn: (at: string, rt: string) => void): void;
+export declare function setAuthClearProvider(fn: () => void): void;
 export declare function getAuthToken(): string | null;
+export declare function getRefreshToken(): string | null;
+export declare function setAuthTokens(at: string, rt: string): void;
+export declare function clearAuth(): void;
+export declare function notifyAuthChanged(): void;

package/dist/adapters/auth.js

@@ -9,9 +9,45 @@ export const useAuthStore = {
     getState: () => ({ user }),
 };
 let getAccessToken = null;
+let getRefresh = null;
+let setTokens = null;
+let clearFn = null;
+const authListeners = new Set();
+export function subscribeAuth(listener) {
+    authListeners.add(listener);
+    return () => authListeners.delete(listener);
+}
+function notifyAuth() {
+    authListeners.forEach((l) => l());
+}
 export function setAuthProvider(fn) {
     getAccessToken = fn;
 }
+export function setAuthRefreshProvider(fn) {
+    getRefresh = fn;
+}
+export function setAuthTokensProvider(fn) {
+    setTokens = fn;
+}
+export function setAuthClearProvider(fn) {
+    clearFn = fn;
+}
 export function getAuthToken() {
     return getAccessToken ? getAccessToken() : null;
 }
+export function getRefreshToken() {
+    return getRefresh ? getRefresh() : null;
+}
+export function setAuthTokens(at, rt) {
+    if (setTokens)
+        setTokens(at, rt);
+    notifyAuth();
+}
+export function clearAuth() {
+    if (clearFn)
+        clearFn();
+    notifyAuth();
+}
+export function notifyAuthChanged() {
+    notifyAuth();
+}

package/dist/adapters/devices.d.ts

@@ -1,5 +1,7 @@
 /**
- * Devices service stub.
+ * Devices service — stable per-device UUID for DD lease.
+ * Persists via KV sync so DD stays same for life of device (until wipe).
  */
 export declare function setAppInstanceId(id: string): void;
 export declare function getAppInstanceId(): string;
+export declare function getAppInstanceIdAsync(): Promise<string>;

package/dist/adapters/devices.js

@@ -1,10 +1,194 @@
 /**
- * Devices service stub.
+ * Devices service — stable per-device UUID for DD lease.
+ * Persists via KV sync so DD stays same for life of device (until wipe).
  */
-let appInstanceId = "core-device-id";
+import { getItemSync, setItemSync, getItem, setItem } from "./kv";
+import { generateUUID } from "../utils/uuid";
+let appInstanceId = null;
+const APP_ID_KEY = "teinc_app_instance_id";
+// 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") {
+        const ls = localStorage.getItem(APP_ID_KEY);
+        if (ls) {
+            let v = ls;
+            try {
+                if (v.startsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8)
+                appInstanceId = v;
+        }
+    }
+}
+catch { }
 export function setAppInstanceId(id) {
     appInstanceId = id;
+    try {
+        setItemSync(APP_ID_KEY, id);
+    }
+    catch { }
 }
 export function getAppInstanceId() {
-    return appInstanceId;
+    if (appInstanceId)
+        return appInstanceId;
+    // Check localStorage first (covers Tauri webview where KVDriver async may race)
+    try {
+        const ls = typeof localStorage !== "undefined" ? localStorage.getItem(APP_ID_KEY) : null;
+        if (ls) {
+            let v = ls;
+            try {
+                if (v.startsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8) {
+                appInstanceId = v;
+                return v;
+            }
+        }
+    }
+    catch { }
+    try {
+        const stored = getItemSync(APP_ID_KEY);
+        if (stored && typeof stored === "string" && stored.length > 8) {
+            let v = stored;
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8) {
+                appInstanceId = v;
+                try {
+                    if (typeof localStorage !== "undefined")
+                        localStorage.setItem(APP_ID_KEY, JSON.stringify(v));
+                }
+                catch { }
+                return v;
+            }
+        }
+    }
+    catch { }
+    const id = generateUUID();
+    appInstanceId = id;
+    try {
+        setItemSync(APP_ID_KEY, id);
+    }
+    catch { }
+    try {
+        if (typeof localStorage !== "undefined")
+            localStorage.setItem(APP_ID_KEY, JSON.stringify(id));
+    }
+    catch { }
+    return id;
+}
+export async function getAppInstanceIdAsync() {
+    if (appInstanceId)
+        return appInstanceId;
+    // Try localStorage directly first (covers desktop webview where KVDriver's async getItem may race with Tauri store load)
+    try {
+        const ls = typeof localStorage !== "undefined" ? localStorage.getItem(APP_ID_KEY) : null;
+        if (ls) {
+            let v = ls;
+            try {
+                if (v.startsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            // Handle double-stringified "\"xxx\""
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8) {
+                appInstanceId = v;
+                return v;
+            }
+        }
+    }
+    catch { }
+    try {
+        const stored = await getItem(APP_ID_KEY);
+        try {
+            const { syncLogger } = require("../utils/sync-logger");
+            syncLogger.debug("Devices", "getAppInstanceIdAsync getItem", { stored, len: stored?.length });
+        }
+        catch { }
+        if (stored && typeof stored === "string" && stored.length > 8) {
+            // Handle double-stringified case "\"xxx\"" from older builds
+            let v = stored;
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8) {
+                appInstanceId = v; // also prime localStorage for sync fallback
+                try {
+                    if (typeof localStorage !== "undefined")
+                        localStorage.setItem(APP_ID_KEY, JSON.stringify(v));
+                }
+                catch { }
+                return v;
+            }
+        }
+    }
+    catch { }
+    // fallback to sync check
+    try {
+        const s = getItemSync(APP_ID_KEY);
+        try {
+            const { syncLogger } = require("../utils/sync-logger");
+            syncLogger.debug("Devices", "getAppInstanceIdAsync getItemSync", { s, len: s?.length });
+        }
+        catch { }
+        if (s && typeof s === "string" && s.length > 8) {
+            let v = s;
+            try {
+                if (v.startsWith('"') && v.endsWith('"'))
+                    v = JSON.parse(v);
+            }
+            catch { }
+            if (v.length > 8) {
+                appInstanceId = v;
+                return v;
+            }
+        }
+    }
+    catch { }
+    const id = generateUUID();
+    appInstanceId = id;
+    try {
+        const { syncLogger } = require("../utils/sync-logger");
+        syncLogger.info("Devices", "generated new appInstanceId", { id });
+    }
+    catch { }
+    try {
+        await setItem(APP_ID_KEY, id);
+    }
+    catch {
+        try {
+            setItemSync(APP_ID_KEY, id);
+        }
+        catch { }
+    }
+    try {
+        if (typeof localStorage !== "undefined")
+            localStorage.setItem(APP_ID_KEY, JSON.stringify(id));
+    }
+    catch { }
+    return id;
 }

package/dist/adapters/filesystem.d.ts

@@ -17,6 +17,10 @@ export interface FileSystemAdapter {
     }): Promise<void>;
     readDirectoryAsync(path: string): Promise<string[]>;
     getDocumentDirectory(): string;
+    readAsStringAsync?(path: string, opts?: {
+        encoding?: string;
+    }): Promise<string>;
+    readAsBase64Async?(path: string): Promise<string>;
 }
 export declare function setFileSystemAdapter(a: FileSystemAdapter | null): void;
 export declare function getFileSystemAdapter(): FileSystemAdapter | null;

package/dist/adapters/kv.d.ts

@@ -6,6 +6,16 @@ export interface KVDriver {
     getItem(key: string): Promise<string | null> | string | null;
     setItem(key: string, value: string): Promise<void> | void;
     removeItem(key: string): Promise<void> | void;
+    /**
+     * Optional synchronous access. Sync callers (e.g. order-number callout
+     * sequencing) MUST read persisted state — an async-only driver makes them
+     * fall back to the ephemeral memory map, silently resetting sequences on
+     * every launch. Drivers backed by async storage (Tauri store) implement
+     * these over a synchronously-readable cache (localStorage + memory).
+     */
+    getItemSync?(key: string): string | null;
+    setItemSync?(key: string, value: string): void;
+    removeItemSync?(key: string): void;
 }
 export declare function setKVDriver(d: KVDriver): void;
 export declare function getKVDriver(): KVDriver;

package/dist/adapters/kv.js

@@ -49,17 +49,25 @@ export async function removeItem(key) {
     await kvRemoveItem(key);
 }
 // Synchronous fallbacks for legacy callers that used MMKV sync API
-// 0.7.1: delegate to driver when driver supports sync (MMKV), otherwise memory
+// 0.7.1: delegate to driver when driver supports sync (MMKV), otherwise memory.
+// Drivers with async storage expose getItemSync/setItemSync over a sync-readable
+// cache — prefer those, else a Promise-returning getItem degrades to the
+// ephemeral memory map (sequences reset every launch).
 export function getItemSync(key) {
     let raw;
     if (driver) {
         try {
-            const v = driver.getItem(key);
-            // if driver returns Promise, we can't await sync — fall back to memory
-            if (v instanceof Promise)
-                raw = memory.get(key) ?? null;
-            else
-                raw = v ?? memory.get(key) ?? null;
+            if (driver.getItemSync) {
+                raw = driver.getItemSync(key) ?? memory.get(key) ?? null;
+            }
+            else {
+                const v = driver.getItem(key);
+                // if driver returns Promise, we can't await sync — fall back to memory
+                if (v instanceof Promise)
+                    raw = memory.get(key) ?? null;
+                else
+                    raw = v ?? memory.get(key) ?? null;
+            }
         }
         catch {
             raw = memory.get(key) ?? null;
@@ -82,6 +90,10 @@ export function setItemSync(key, value) {
     memory.set(key, str);
     if (driver) {
         try {
+            if (driver.setItemSync) {
+                driver.setItemSync(key, str);
+                return;
+            }
             const r = driver.setItem(key, str);
             // if async, also keep memory
             if (r instanceof Promise)
@@ -94,6 +106,10 @@ export function removeItemSync(key) {
     memory.delete(key);
     if (driver) {
         try {
+            if (driver.removeItemSync) {
+                driver.removeItemSync(key);
+                return;
+            }
             const r = driver.removeItem(key);
             if (r instanceof Promise)
                 r.catch(() => { });

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

@@ -1,12 +1,10 @@
 /**
- * Local Node stubs — minimal interfaces so core compiles without RN.
- * Host apps with LAN support replace these via setters.
+ * Local Node adapters — re-export core-owned implementation for compat.
+ * Host apps should import from @teincfood/core/local-node instead.
  */
 import type { Command, DomainEvent } from "../sync/types";
-export interface LocalNodeClient {
-    execute(command: Command): Promise<DomainEvent[]>;
-    publishEvent?(event: DomainEvent): void | Promise<void>;
-}
+import type { LocalNodeClient as CoreClient } from "../local-node/adapters";
+export type LocalNodeClient = CoreClient;
 export interface ElectedNode {
     deviceId: string;
 }

package/dist/adapters/local-node.js

@@ -1,36 +1,13 @@
 /**
- * Local Node stubs — minimal interfaces so core compiles without RN.
- * Host apps with LAN support replace these via setters.
+ * Local Node adapters — re-export core-owned implementation for compat.
+ * Host apps should import from @teincfood/core/local-node instead.
  */
-let isLocalEnabled = false;
-let isConnected = false;
-let isLocalNodeFlag = false;
-let electedNode = null;
-let client = null;
+import { localNodeService as coreService } from "../local-node/service";
+import { useLocalNodeStore as coreStore } from "../local-node/store";
 export function setLocalNodeState(s) {
-    if (s.isLocalNodeEnabled !== undefined)
-        isLocalEnabled = s.isLocalNodeEnabled;
-    if (s.isConnectedToNode !== undefined)
-        isConnected = s.isConnectedToNode;
-    if (s.isLocalNode !== undefined)
-        isLocalNodeFlag = s.isLocalNode;
-    if (s.electedNode !== undefined)
-        electedNode = s.electedNode;
-    if (s.client !== undefined)
-        client = s.client;
+    // Compat: no-op — core store/service is source of truth.
+    // Business/Desktop bootstrap now calls initLocalNodeService(deps).
+    void s;
 }
-export const localNodeService = {
-    isLocalNode: () => isLocalNodeFlag,
-    isConnectedToNode: () => isConnected,
-    getElectedNode: () => electedNode,
-    getClient: () => client,
-    broadcastToClients: (_event) => { },
-    handleNodeCommand: async (_command) => null,
-};
-export const useLocalNodeStore = {
-    getState: () => ({
-        isLocalNodeEnabled: isLocalEnabled,
-        isConnectedToNode: isConnected,
-        electedNode,
-    }),
-};
+export const localNodeService = coreService;
+export const useLocalNodeStore = coreStore;

package/dist/adapters/notify.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Notify adapter — platform toast injection (sonner on desktop,
+ * sonner-native on mobile). Core hooks never import a toast library.
+ */
+interface NotifyHandlers {
+    success: (message: string) => void;
+    error: (message: string) => void;
+}
+export declare function setNotifyHandlers(next: Partial<NotifyHandlers>): void;
+export declare function notifySuccess(message: string): void;
+export declare function notifyError(message: string): void;
+export {};

package/dist/adapters/notify.js

@@ -0,0 +1,33 @@
+/**
+ * Notify adapter — platform toast injection (sonner on desktop,
+ * sonner-native on mobile). Core hooks never import a toast library.
+ */
+let handlers = {
+    success: (m) => {
+        try {
+            console.debug("[notify] success", m);
+        }
+        catch { }
+    },
+    error: (m) => {
+        try {
+            console.debug("[notify] error", m);
+        }
+        catch { }
+    },
+};
+export function setNotifyHandlers(next) {
+    handlers = { ...handlers, ...next };
+}
+export function notifySuccess(message) {
+    try {
+        handlers.success(message);
+    }
+    catch { }
+}
+export function notifyError(message) {
+    try {
+        handlers.error(message);
+    }
+    catch { }
+}

package/dist/adapters/query-keys.d.ts

@@ -25,3 +25,7 @@ export declare const MENU_KEYS: {
 export declare const REFERENCE_KEYS: {
     all: readonly ["reference"];
 };
+export declare const SELLER_DASHBOARD_KEYS: {
+    all: readonly ["seller-dashboard"];
+    full: (businessId?: string) => readonly unknown[];
+};

package/dist/adapters/query-keys.js

@@ -25,3 +25,7 @@ export const MENU_KEYS = {
 export const REFERENCE_KEYS = {
     all: ["reference"],
 };
+export const SELLER_DASHBOARD_KEYS = {
+    all: ["seller-dashboard"],
+    full: (businessId) => ["seller-dashboard", "full", businessId].filter((x) => x !== undefined),
+};