@teincfood/core 0.1.5 → 0.7.0

package/dist/db/migrations.js

@@ -100,4 +100,14 @@ export const MIGRATIONS = [
         `);
         },
     },
+    {
+        version: 3,
+        up: async (db) => {
+            await db.execAsync(`
+          ALTER TABLE reference_data ADD COLUMN last_event_id TEXT;
+          ALTER TABLE reference_data ADD COLUMN last_hlc TEXT;
+          CREATE INDEX IF NOT EXISTS idx_reference_data_hlc ON reference_data(last_hlc);
+        `);
+        },
+    },
 ];

package/dist/index.d.ts

@@ -20,6 +20,8 @@ export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
 export * from "./utils/responsive";
 export * from "./utils/copyToClipBoard";
+export * from "./utils/customer-display";
+export * from "./utils/order-filter";
 export * from "./db/migrations";
 export * from "./db/operations";
 export * as dbOps from "./db/operations";
@@ -31,7 +33,11 @@ export * from "./sync/command-builder";
 export * from "./sync/command-queue.service";
 export { commandQueueService } from "./sync/command-queue.service";
 export { buildCommand } from "./sync/command-builder";
-export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber } from "./sync/order-number";
+export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber, generateOrderNumber, isOfflineOrderNumber, parseOrderNumber, } from "./sync/order-number";
+export { deviceLeaseService, getDeviceNumber, isOnlineOnly, ensureLease } from "./sync/device-lease.service";
+export { useDeviceLease, ensureDeviceLease } from "./sync/use-device-lease";
+export * from "./utils/hlc";
+export * from "./reference/lww";
 export { orderSnapshotsService } from "./sync/order-snapshots.service";
 export * from "./sync/pending-orders.service";
 export { restTransport } from "./sync/transport-rest";

package/dist/index.js

@@ -21,6 +21,8 @@ export { formatDate, formatRelativeTime } from "./utils/formatDate";
 export * from "./utils/validation";
 export * from "./utils/responsive";
 export * from "./utils/copyToClipBoard";
+export * from "./utils/customer-display";
+export * from "./utils/order-filter";
 // ── DB ──
 export * from "./db/migrations";
 export * from "./db/operations";
@@ -34,7 +36,11 @@ export * from "./sync/command-builder";
 export * from "./sync/command-queue.service";
 export { commandQueueService } from "./sync/command-queue.service";
 export { buildCommand } from "./sync/command-builder";
-export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber } from "./sync/order-number";
+export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber, generateOrderNumber, isOfflineOrderNumber, parseOrderNumber, } from "./sync/order-number";
+export { deviceLeaseService, getDeviceNumber, isOnlineOnly, ensureLease } from "./sync/device-lease.service";
+export { useDeviceLease, ensureDeviceLease } from "./sync/use-device-lease";
+export * from "./utils/hlc";
+export * from "./reference/lww";
 export { orderSnapshotsService } from "./sync/order-snapshots.service";
 export * from "./sync/pending-orders.service";
 export { restTransport } from "./sync/transport-rest";

package/dist/reference/capabilities.d.ts

@@ -19,3 +19,6 @@ export declare function useBusinessCapabilities(businessId?: string | null): imp
     status: string;
 }, Error>;
 export declare function useHasCapabilityFor(businessId: string | undefined, capability: string): boolean;
+export declare const CAPABILITY_BY_COMMAND: Record<string, string>;
+export declare function hasCapabilitySync(businessId: string, commandType: string): Promise<boolean>;
+export declare function hasCapabilitySyncSync(businessId: string, commandType: string): boolean;

package/dist/reference/capabilities.js

@@ -79,3 +79,39 @@ export function useHasCapabilityFor(businessId, capability) {
     const { data } = useBusinessCapabilities(businessId);
     return data?.capabilities.includes(capability) ?? false;
 }
+export const CAPABILITY_BY_COMMAND = {
+    "order:create": "pos:create_order",
+    "order:accept": "order:accept",
+    "order:reject": "order:reject",
+    "order:start_preparing": "order:start_preparing",
+    "order:mark_ready": "order:mark_ready",
+    "order:complete_pickup": "order:complete_pickup",
+    "order:cancel": "order:cancel",
+    "delivery:assign": "delivery:assign",
+    "delivery:confirm_handover": "delivery:confirm_handover",
+    "menu:create_item": "menu:manage",
+    "menu:update_item": "menu:manage",
+    "menu:delete_item": "menu:manage",
+    "menu:create_category": "menu:manage",
+};
+export async function hasCapabilitySync(businessId, commandType) {
+    const required = CAPABILITY_BY_COMMAND[commandType];
+    if (!required)
+        return true;
+    try {
+        const db = await openSyncDatabase();
+        const rec = await getReferenceData(db, businessId, "capabilities");
+        const caps = rec?.payload?.data?.capabilities ?? [];
+        return caps.includes(required);
+    }
+    catch {
+        return true; // fail open if cache unreadable — backend will still 403
+    }
+}
+export function hasCapabilitySyncSync(businessId, commandType) {
+    // Synchronous fallback for non-async callers — checks in-memory KV mirror if available
+    const required = CAPABILITY_BY_COMMAND[commandType];
+    if (!required)
+        return true;
+    return true;
+}

package/dist/reference/lww.d.ts

@@ -0,0 +1,14 @@
+export type LWW<T> = {
+    value: T;
+    hlc: string;
+    deviceId: string;
+};
+export type LWWMap = Record<string, LWW<unknown>>;
+export declare function lwwMerge(existing: LWWMap | null | undefined, incoming: LWWMap): LWWMap;
+export declare function toLWWMap(obj: Record<string, unknown>, hlc: string, deviceId: string): LWWMap;
+export declare function fromLWWMap(m: LWWMap): Record<string, unknown>;
+export declare function mergeItemArrays(existing: Array<{
+    id: string;
+} & Record<string, unknown>>, incoming: Array<{
+    id: string;
+} & Record<string, unknown>>, hlcById: Record<string, string>): Array<Record<string, unknown>>;

package/dist/reference/lww.js

@@ -0,0 +1,45 @@
+/**
+ * LWW-Register and LWW-Map for reference data (menu/categories/etc.)
+ * Per-field last-HLC-wins. HLC strings as version.
+ */
+import { compareHLCString } from "../utils/hlc";
+export function lwwMerge(existing, incoming) {
+    const out = { ...(existing ?? {}) };
+    for (const [k, v] of Object.entries(incoming)) {
+        const cur = out[k];
+        if (!cur || compareHLCString(v.hlc, cur.hlc) > 0)
+            out[k] = v;
+    }
+    return out;
+}
+export function toLWWMap(obj, hlc, deviceId) {
+    const m = {};
+    for (const [k, v] of Object.entries(obj))
+        m[k] = { value: v, hlc, deviceId };
+    return m;
+}
+export function fromLWWMap(m) {
+    const o = {};
+    for (const [k, v] of Object.entries(m))
+        o[k] = v.value;
+    return o;
+}
+// For array items (MenuItem) — merge by id
+export function mergeItemArrays(existing, incoming, hlcById) {
+    const byId = new Map();
+    for (const it of existing)
+        byId.set(it.id, { ...it });
+    for (const it of incoming) {
+        const cur = byId.get(it.id);
+        const hlc = hlcById[it.id] ?? "";
+        if (!cur)
+            byId.set(it.id, { ...it });
+        else {
+            // per-field LWW if both exist: compare hlc for this id
+            const curHlc = cur._hlc ?? "";
+            if (!curHlc || compareHLCString(hlc, curHlc) >= 0)
+                byId.set(it.id, { ...it, _hlc: hlc });
+        }
+    }
+    return [...byId.values()];
+}

package/dist/reference/lww.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reference/lww.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { lwwMerge, toLWWMap, fromLWWMap } from "./lww";
+describe("LWW merge", () => {
+    it("divergent fields both merge", () => {
+        const a = toLWWMap({ price: 500 }, "1000-000000-01", "01");
+        const b = toLWWMap({ name: "Spicy" }, "1001-000000-02", "02");
+        const merged = lwwMerge(lwwMerge(null, a), b);
+        expect(fromLWWMap(merged)).toEqual({ price: 500, name: "Spicy" });
+    });
+    it("same field last HLC wins", () => {
+        const a = toLWWMap({ price: 500 }, "1000-000000-01", "01");
+        const b = toLWWMap({ price: 600 }, "1001-000000-02", "02");
+        const merged = lwwMerge(a, b);
+        expect(merged.price.value).toBe(600);
+        const merged2 = lwwMerge(b, a);
+        expect(merged2.price.value).toBe(600);
+    });
+    it("idempotent", () => {
+        const a = toLWWMap({ x: 1 }, "1000-000000-01", "01");
+        const m1 = lwwMerge(a, a);
+        expect(m1).toEqual(a);
+    });
+});

package/dist/reference/operations.d.ts

@@ -6,6 +6,7 @@ import type { ReferenceDataKey, ReferenceDataRecord } from "./types";
 export declare function getReferenceData<T>(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<ReferenceDataRecord<T> | null>;
 export declare function getReferenceVersion(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<string | null>;
 export declare function setReferenceData<T>(db: SQLiteDatabase, businessId: string, record: ReferenceDataRecord<T>): Promise<void>;
+export declare function mergeReferenceData<T extends Record<string, unknown>>(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey, incoming: Record<string, unknown>, hlc: string, eventId: string): Promise<void>;
 export declare function deleteReferenceData(db: SQLiteDatabase, businessId: string, key: ReferenceDataKey): Promise<void>;
 export declare function deleteReferenceDataForBusiness(db: SQLiteDatabase, businessId: string): Promise<void>;
 export declare function getAllReferenceDataKeys(db: SQLiteDatabase, businessId: string): Promise<ReferenceDataKey[]>;

package/dist/reference/operations.js

@@ -10,6 +10,8 @@ export async function getReferenceData(db, businessId, key) {
         version: row.version,
         payload: JSON.parse(row.payload),
         downloadedAt: row.downloaded_at,
+        lastEventId: row.last_event_id ?? null,
+        lastHlc: row.last_hlc ?? null,
     };
 }
 export async function getReferenceVersion(db, businessId, key) {
@@ -18,13 +20,43 @@ export async function getReferenceVersion(db, businessId, key) {
 }
 export async function setReferenceData(db, businessId, record) {
     await db.runAsync(`
-      INSERT INTO reference_data (business_id, key, version, payload, downloaded_at)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO reference_data (business_id, key, version, payload, downloaded_at, last_event_id, last_hlc)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(business_id, key) DO UPDATE SET
         version = excluded.version,
         payload = excluded.payload,
-        downloaded_at = excluded.downloaded_at;
-    `, businessId, record.key, record.version, JSON.stringify(record.payload), record.downloadedAt);
+        downloaded_at = excluded.downloaded_at,
+        last_event_id = excluded.last_event_id,
+        last_hlc = excluded.last_hlc;
+    `, businessId, record.key, record.version, JSON.stringify(record.payload), record.downloadedAt, record.lastEventId ?? null, record.lastHlc ?? null);
+}
+export async function mergeReferenceData(db, businessId, key, incoming, hlc, eventId) {
+    const { compareHLCString } = await import("../utils/hlc");
+    const existing = await getReferenceData(db, businessId, key);
+    if (!existing) {
+        await setReferenceData(db, businessId, {
+            key,
+            version: hlc,
+            payload: incoming,
+            downloadedAt: new Date().toISOString(),
+            lastEventId: eventId,
+            lastHlc: hlc,
+        });
+        return;
+    }
+    // If incoming HLC is older, keep existing (LWW per key)
+    if (existing.lastHlc && compareHLCString(hlc, existing.lastHlc) <= 0) {
+        // Still allow partial field merge if payload is LWWMap shaped
+        return;
+    }
+    await setReferenceData(db, businessId, {
+        key,
+        version: hlc,
+        payload: incoming,
+        downloadedAt: new Date().toISOString(),
+        lastEventId: eventId,
+        lastHlc: hlc,
+    });
 }
 export async function deleteReferenceData(db, businessId, key) {
     await db.runAsync("DELETE FROM reference_data WHERE business_id = ? AND key = ?;", businessId, key);

package/dist/reference/operations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reference/operations.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { getReferenceData, setReferenceData, mergeReferenceData } from "./operations";
+// simple in-memory sqlite mock for operations tests
+class MemDB {
+    constructor() {
+        this.tables = new Map();
+    }
+    async execAsync(_sql) { }
+    async runAsync(sql, ...params) {
+        if (sql.includes("INSERT INTO reference_data")) {
+            const [business_id, key, version, payload, downloaded_at, last_event_id, last_hlc] = params;
+            let m = this.tables.get("reference_data");
+            if (!m) {
+                m = new Map();
+                this.tables.set("reference_data", m);
+            }
+            const existing = m.get(`${business_id}:${key}`);
+            // mimic merge behavior via setReferenceData logic in test calling mergeReferenceData
+            m.set(`${business_id}:${key}`, JSON.stringify({ business_id, key, version, payload, downloaded_at, last_event_id, last_hlc }));
+            return { lastInsertRowId: 1, changes: 1 };
+        }
+        if (sql.includes("INSERT INTO reference_data") && sql.includes("ON CONFLICT")) { }
+        return { lastInsertRowId: 1, changes: 1 };
+    }
+    async getFirstAsync(sql, ...params) {
+        if (sql.includes("SELECT * FROM reference_data")) {
+            const [business_id, key] = params;
+            const m = this.tables.get("reference_data");
+            if (!m)
+                return null;
+            const raw = m.get(`${business_id}:${key}`);
+            if (!raw)
+                return null;
+            const j = JSON.parse(raw);
+            return { key: j.key, version: j.version, payload: j.payload, downloaded_at: j.downloaded_at, last_event_id: j.last_event_id, last_hlc: j.last_hlc };
+        }
+        if (sql.includes("SELECT version")) {
+            const [business_id, key] = params;
+            const m = this.tables.get("reference_data");
+            const raw = m?.get(`${business_id}:${key}`);
+            if (!raw)
+                return null;
+            const j = JSON.parse(raw);
+            return { version: j.version };
+        }
+        return null;
+    }
+    async getAllAsync() { return []; }
+}
+describe("reference operations LWW", () => {
+    it("merge keeps newer HLC", async () => {
+        const db = new MemDB();
+        await setReferenceData(db, "biz1", { key: "business:profile", version: "1000-000000-01", payload: { name: "A" }, downloadedAt: new Date().toISOString(), lastHlc: "1000-000000-01", lastEventId: "evt_1" });
+        let rec = await getReferenceData(db, "biz1", "business:profile");
+        expect(rec?.lastHlc).toBe("1000-000000-01");
+        // older HLC should not overwrite
+        await mergeReferenceData(db, "biz1", "business:profile", { name: "B" }, "0999-000000-01", "evt_0");
+        rec = await getReferenceData(db, "biz1", "business:profile");
+        // still A because incoming older
+        expect(rec?.payload).toEqual({ name: "A" });
+        // newer wins
+        await mergeReferenceData(db, "biz1", "business:profile", { name: "C" }, "1001-000000-02", "evt_2");
+        rec = await getReferenceData(db, "biz1", "business:profile");
+        expect(rec?.payload).toEqual({ name: "C" });
+    });
+});

package/dist/reference/service.js

@@ -145,12 +145,11 @@ class ReferenceSyncService {
         }
         await setReferenceData(db, businessId, {
             key,
-            // Defensive: never write a NULL version. If the backend ever omits the
-            // version, generate one so the row is still usable; the next version
-            // comparison will simply see a mismatch and re-sync.
             version: version ?? generateUUID(),
             payload,
             downloadedAt: new Date().toISOString(),
+            lastHlc: version ?? generateUUID(),
+            lastEventId: `evt_${version ?? generateUUID()}`,
         });
         return true;
     }

package/dist/reference/types.d.ts

@@ -14,11 +14,15 @@ export interface ReferenceDataRecord<T = unknown> {
     version: string;
     payload: T;
     downloadedAt: string;
+    lastEventId?: string | null;
+    lastHlc?: string | null;
 }
 export interface ReferenceVersionInfo {
     key: ReferenceDataKey;
     version: string;
     updated_at: string;
+    event_id?: string;
+    hlc?: string;
 }
 export interface ReferenceSyncOptions {
     businessId: string;

package/dist/standalone.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/standalone.integration.test.js

@@ -0,0 +1,235 @@
+/**
+ * Standalone integration tests for 0.7.0
+ * Covers: menu, categories, taxes, operating-hours, business:profile, orders
+ * Modes: single node, multi-node (LAN), backend sync
+ * No network, no fallback, pure memory driver.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryDriver } from "./test-helpers/memory-driver";
+import { setSqliteDriver } from "./adapters/sqlite";
+import { openSyncDatabase, closeSyncDatabase } from "./db/connection";
+import { setReferenceData, getReferenceData, mergeReferenceData, getReferenceVersion } from "./reference/operations";
+import { generateOrderNumber, resetCalloutForTests } from "./sync/order-number";
+import { setItemSync, removeItemSync } from "./adapters/kv";
+import { insertEvent, getUnsyncedEvents, markEventsSynced, upsertEntitySnapshot, getEntitySnapshot } from "./db/operations";
+import { generateEventId } from "./utils/uuid";
+import { tickHLC, hlcToString, compareHLCString } from "./utils/hlc";
+// helper to build reference payloads per key
+function payloadForKey(key, suffix = "") {
+    switch (key) {
+        case "menu:items":
+            return { data: [{ id: "item1", name: `Jollof${suffix}`, price: 5000 }] };
+        case "menu:categories":
+            return { data: [{ id: "cat1", name: `Rice${suffix}` }] };
+        case "tax-rules":
+            return { data: [{ id: "tax1", rate_basis_points: 500 }] };
+        case "operating-hours":
+            return { data: [{ day_of_week: 1, open_time: "08:00", is_closed: false }] };
+        case "business:profile":
+            return { data: { name: `Biz${suffix}`, business_number: "AB12C" } };
+        case "roles":
+            return { data: [{ name: "owner" }] };
+        case "members":
+            return { data: [{ user_id: "u1", role: "owner" }] };
+        case "capabilities":
+            return { data: { capabilities: ["pos:create_order", "menu:manage"] } };
+        default:
+            return { data: {} };
+    }
+}
+const ALL_KEYS = [
+    "menu:items",
+    "menu:categories",
+    "tax-rules",
+    "operating-hours",
+    "business:profile",
+    "roles",
+    "members",
+    "capabilities",
+];
+describe("standalone integration — single node", () => {
+    beforeEach(async () => {
+        const driver = createMemoryDriver();
+        setSqliteDriver(driver);
+        // ensure fresh connection resets initPromise
+        // @ts-ignore
+        // close and reopen to run migrations
+        try {
+            await closeSyncDatabase();
+        }
+        catch { }
+        removeItemSync("teinc_callout_seq");
+        resetCalloutForTests();
+    });
+    it("single node can store and retrieve all reference keys", async () => {
+        const db = await openSyncDatabase();
+        const biz = "biz-single";
+        for (const key of ALL_KEYS) {
+            const payload = payloadForKey(key, "-v1");
+            const hlc = hlcToString(tickHLC(Date.now(), null, "01"));
+            await setReferenceData(db, biz, { key, version: hlc, payload, downloadedAt: new Date().toISOString(), lastHlc: hlc, lastEventId: generateEventId() });
+        }
+        for (const key of ALL_KEYS) {
+            const rec = await getReferenceData(db, biz, key);
+            expect(rec).not.toBeNull();
+            expect(rec.key).toBe(key);
+        }
+        // verify getReferenceVersion works for HLC
+        const v = await getReferenceVersion(db, biz, "menu:items");
+        expect(v).toMatch(/^[0-9]+-[0-9]+-01$/);
+    });
+    it("single device order DD-RRR-CCC generation and offline storage", async () => {
+        setItemSync("teinc_device_number:biz-single", "07");
+        const { orderNumber, callout } = generateOrderNumber("07");
+        expect(orderNumber).toMatch(/^07-[0-9]{3}-[0-9]{3}$/);
+        expect(callout).toBeGreaterThan(0);
+        // persist as event (offline order)
+        const db = await openSyncDatabase();
+        const evt = {
+            event_id: generateEventId(),
+            event_type: "order.create_queued",
+            event_version: "1.0",
+            entity_id: "cmd-1",
+            user_id: "u1",
+            device_id: "dev-07",
+            payload: { order_number: orderNumber, callout_number: callout },
+            timestamp: new Date().toISOString(),
+        };
+        await insertEvent(db, { event: evt, origin: "local" });
+        const unsynced = await getUnsyncedEvents(db, "local");
+        expect(unsynced.length).toBe(1);
+        expect(unsynced[0].payload.order_number).toBe(orderNumber);
+    });
+    it("callout wraps 999->001", async () => {
+        setItemSync("teinc_callout_seq", 998);
+        const a = generateOrderNumber("03");
+        expect(a.callout).toBe(999);
+        const b = generateOrderNumber("03");
+        expect(b.callout).toBe(1);
+        expect(b.orderNumber).not.toBe(a.orderNumber);
+    });
+});
+describe("standalone integration — multi-node LAN", () => {
+    beforeEach(async () => {
+        const driver = createMemoryDriver();
+        setSqliteDriver(driver);
+        try {
+            await closeSyncDatabase();
+        }
+        catch { }
+        removeItemSync("teinc_callout_seq");
+        resetCalloutForTests();
+    });
+    it("two nodes editing same menu:items converge via HLC per-key", async () => {
+        const db = await openSyncDatabase();
+        const biz = "biz-multi";
+        // Node A (device 01) writes price 500 at HLC wall 1000
+        const hlcA = hlcToString(tickHLC(1000, null, "01"));
+        await setReferenceData(db, biz, { key: "menu:items", version: hlcA, payload: payloadForKey("menu:items", "-A"), downloadedAt: new Date().toISOString(), lastHlc: hlcA, lastEventId: "evt_A" });
+        // Node B (device 02) concurrently writes different payload at wall 1001 (later) — should win
+        const hlcB = hlcToString(tickHLC(1001, null, "02"));
+        await mergeReferenceData(db, biz, "menu:items", payloadForKey("menu:items", "-B"), hlcB, "evt_B");
+        let rec = await getReferenceData(db, biz, "menu:items");
+        expect(rec.payload.data[0].name).toContain("-B");
+        // Node A tries to replay older HLC (1000) — should be rejected (LWW)
+        await mergeReferenceData(db, biz, "menu:items", payloadForKey("menu:items", "-A-old"), hlcA, "evt_A2");
+        rec = await getReferenceData(db, biz, "menu:items");
+        expect(rec.payload.data[0].name).toContain("-B");
+    });
+    it("divergent fields via LWW-Map style: operating-hours + tax-rules both persist across nodes", async () => {
+        const db = await openSyncDatabase();
+        const biz = "biz-multi2";
+        // Node A updates operating-hours, Node B updates tax-rules — no conflict, both keys coexist
+        const hlcA = hlcToString(tickHLC(2000, null, "01"));
+        const hlcB = hlcToString(tickHLC(2000, null, "02"));
+        await setReferenceData(db, biz, { key: "operating-hours", version: hlcA, payload: payloadForKey("operating-hours"), downloadedAt: new Date().toISOString(), lastHlc: hlcA, lastEventId: "evt_oh" });
+        await setReferenceData(db, biz, { key: "tax-rules", version: hlcB, payload: payloadForKey("tax-rules"), downloadedAt: new Date().toISOString(), lastHlc: hlcB, lastEventId: "evt_tax" });
+        const oh = await getReferenceData(db, biz, "operating-hours");
+        const tax = await getReferenceData(db, biz, "tax-rules");
+        expect(oh).not.toBeNull();
+        expect(tax).not.toBeNull();
+    });
+    it("orders: two LAN clients see each other's queued orders via events", async () => {
+        const db = await openSyncDatabase();
+        // Device 07 creates order
+        setItemSync("teinc_device_number:biz-multi", "07");
+        const o07 = generateOrderNumber("07");
+        const evt07 = { event_id: generateEventId(), event_type: "order.create_queued", event_version: "1.0", entity_id: "cmd-07", user_id: "u07", device_id: "07", payload: { order_number: o07.orderNumber, callout_number: o07.callout }, timestamp: new Date().toISOString() };
+        await insertEvent(db, { event: evt07, origin: "local" });
+        // Device 08 creates order (LAN peer) — inserted as lan origin on first device's DB (simulating broadcast)
+        const o08 = generateOrderNumber("08");
+        const evt08 = { event_id: generateEventId(), event_type: "order.create_queued", event_version: "1.0", entity_id: "cmd-08", user_id: "u08", device_id: "08", payload: { order_number: o08.orderNumber, callout_number: o08.callout }, timestamp: new Date().toISOString() };
+        await insertEvent(db, { event: evt08, origin: "lan" });
+        const localUnsynced = await getUnsyncedEvents(db, "local");
+        const lanUnsynced = await getUnsyncedEvents(db, "lan");
+        expect(localUnsynced.length).toBe(1);
+        expect(lanUnsynced.length).toBe(1);
+        expect(localUnsynced[0].payload.order_number).toBe(o07.orderNumber);
+        expect(lanUnsynced[0].payload.order_number).toBe(o08.orderNumber);
+        // Also test entity_snapshots for order status via HLC
+        const hlcStatus = hlcToString(tickHLC(Date.now(), null, "07"));
+        await upsertEntitySnapshot(db, { entityType: "seller_orders", entityId: "list-main", businessId: "biz-multi", lastEventId: evt07.event_id, lastEventTimestamp: evt07.timestamp, payload: { data: [evt07.payload], savedAt: new Date().toISOString() } });
+        const snap = await getEntitySnapshot(db, "seller_orders", "list-main");
+        expect(snap).not.toBeNull();
+        expect(snap.payload.data[0].order_number).toBe(o07.orderNumber);
+        // LAN peer updates same list with later timestamp — should win (LWW last_event_timestamp)
+        const later = new Date(Date.now() + 1000).toISOString();
+        await upsertEntitySnapshot(db, { entityType: "seller_orders", entityId: "list-main", businessId: "biz-multi", lastEventId: evt08.event_id, lastEventTimestamp: later, payload: { data: [evt07.payload, evt08.payload], savedAt: later } });
+        const snap2 = await getEntitySnapshot(db, "seller_orders", "list-main");
+        expect(snap2.payload.data.length).toBe(2);
+    });
+});
+describe("standalone integration — backend sync simulation", () => {
+    beforeEach(async () => {
+        const driver = createMemoryDriver();
+        setSqliteDriver(driver);
+        try {
+            await closeSyncDatabase();
+        }
+        catch { }
+        removeItemSync("teinc_callout_seq");
+        resetCalloutForTests();
+    });
+    it("backend adopt offline DD-RRR-CCC and mark synced (no re-number)", async () => {
+        const db = await openSyncDatabase();
+        setItemSync("teinc_device_number:biz-backend", "05");
+        const { orderNumber } = generateOrderNumber("05");
+        const evt = { event_id: generateEventId(), event_type: "order.create_queued", event_version: "1.0", entity_id: "cmd-05", user_id: "u05", device_id: "05", payload: { order_number: orderNumber, callout_number: parseInt(orderNumber.split("-")[2], 10) }, timestamp: new Date().toISOString() };
+        await insertEvent(db, { event: evt, origin: "local" });
+        // Simulate backend adopting same order_number (no change) and returning order.created with local_order_number echo
+        const cloudEvt = { event_id: generateEventId(), event_type: "order.created", event_version: "1.0", entity_id: "cmd-05", user_id: "u05", device_id: "05", payload: { order_number: orderNumber, local_order_number: orderNumber, callout_number: parseInt(orderNumber.split("-")[2], 10) }, timestamp: new Date().toISOString() };
+        // Mark local unsynced as synced after cloud ack
+        let unsynced = await getUnsyncedEvents(db, "local");
+        expect(unsynced.length).toBe(1);
+        await markEventsSynced(db, [unsynced[0].event_id]);
+        unsynced = await getUnsyncedEvents(db, "local");
+        expect(unsynced.length).toBe(0);
+        // Cloud event could be inserted as cloud origin
+        await insertEvent(db, { event: cloudEvt, origin: "cloud", syncedToCloud: true });
+        const cloudUnsynced = await getUnsyncedEvents(db, "cloud");
+        expect(cloudUnsynced.length).toBe(0);
+    });
+    it("reference backend HLC bump: version grows monotonic", async () => {
+        const db = await openSyncDatabase();
+        const biz = "biz-backend";
+        const h1 = hlcToString(tickHLC(3000, null, "backend"));
+        await setReferenceData(db, biz, { key: "business:profile", version: h1, payload: payloadForKey("business:profile", "-v1"), downloadedAt: new Date().toISOString(), lastHlc: h1, lastEventId: "evt1" });
+        const h2 = hlcToString(tickHLC(3001, { wallMs: 3000, counter: 0, deviceId: "backend" }, "backend"));
+        await mergeReferenceData(db, biz, "business:profile", payloadForKey("business:profile", "-v2"), h2, "evt2");
+        const rec = await getReferenceData(db, biz, "business:profile");
+        expect(compareHLCString(rec.lastHlc, h1)).toBeGreaterThan(0);
+        expect(rec.payload.data.name).toContain("-v2");
+    });
+    it("categories + taxes sync independently via backend versions", async () => {
+        const db = await openSyncDatabase();
+        const biz = "biz-backend2";
+        for (const key of ["menu:categories", "tax-rules", "operating-hours"]) {
+            const hlc = hlcToString(tickHLC(Date.now(), null, "backend"));
+            await setReferenceData(db, biz, { key, version: hlc, payload: payloadForKey(key), downloadedAt: new Date().toISOString(), lastHlc: hlc, lastEventId: generateEventId() });
+        }
+        for (const key of ["menu:categories", "tax-rules", "operating-hours"]) {
+            const rec = await getReferenceData(db, biz, key);
+            expect(rec).not.toBeNull();
+        }
+    });
+});