@teincfood/core 0.1.6 → 0.7.1

package/dist/sync/command-queue.service.js

@@ -12,7 +12,7 @@ import { getSyncDatabase, openSyncDatabase } from "../db/connection";
 import { insertCommand, getPendingCommands, markCommandInFlight, updateCommandStatus, deleteCommand, insertEvent, } from "../db/operations";
 import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
-import { generateLocalOrderNumber, generateLocalCalloutNumber, } from "./order-number";
+import { generateLocalCalloutNumber, generateOrderNumberForBusiness, } from "./order-number";
 const MAX_RETRIES = 5;
 const QUEUED_STATUS_BY_COMMAND = {
     "order:accept": "accepted",
@@ -65,7 +65,7 @@ function buildOptimisticOrder(command, payload) {
     const items = payload.items ?? [];
     const totalMinor = payload.total_minor ?? 0;
     const now = new Date().toISOString();
-    const orderNumber = payload.order_number ?? generateLocalOrderNumber();
+    const orderNumber = payload.order_number ?? generateOrderNumberForBusiness(command.business_id);
     return {
         id: command.entity_id ?? command.command_id,
         order_number: orderNumber,
@@ -125,11 +125,13 @@ function injectLocalOrderNumber(command) {
     const payload = command.payload;
     if (payload.order_number)
         return command;
+    // 0.7.0: business-scoped DD-RRR-CCC; requires leased device_number
+    const orderNumber = generateOrderNumberForBusiness(command.business_id);
     return {
         ...command,
         payload: {
             ...payload,
-            order_number: generateLocalOrderNumber(),
+            order_number: orderNumber,
         },
     };
 }
@@ -216,9 +218,31 @@ class CommandQueueService {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            // Distinguish retryable (network/5xx/timeout) vs non-retryable (4xx validation)
-            // so a rejected order does not block the entire outbox.
             const apiErr = error;
+            // 409 ORDER_NUMBER_TAKEN is retryable once with new RRR
+            const code = apiErr?.code ?? apiErr?.data?.code;
+            if (apiErr?.status === 409 && String(code).includes("ORDER_NUMBER_TAKEN")) {
+                // Regenerate random part of order_number if this was order:create
+                if (command.command_type === "order:create") {
+                    try {
+                        const payload = command.payload;
+                        const on = payload.order_number;
+                        const parsed = on ? on.match(/^([0-9]{2})-([0-9]{3})-([0-9]{3})$/) : null;
+                        if (parsed) {
+                            const deviceNumber = parsed[1];
+                            const { generateOrderNumber } = await import("./order-number");
+                            const { orderNumber: newOn } = generateOrderNumber(deviceNumber);
+                            const newPayload = { ...payload, order_number: newOn };
+                            await updateCommandStatus(db, command.command_id, "failed", `retry_random:${message}`);
+                            // Update stored payload for retry
+                            await db.runAsync(`UPDATE commands SET payload = ?, retry_count = retry_count WHERE command_id = ?;`, JSON.stringify(newPayload), command.command_id);
+                        }
+                    }
+                    catch { }
+                }
+                await updateCommandStatus(db, command.command_id, "failed", `order_number_taken:${message}`);
+                throw error;
+            }
             const isNonRetryable = apiErr?.name === "ApiError" &&
                 typeof apiErr.status === "number" &&
                 apiErr.status >= 400 &&

package/dist/sync/device-lease.service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Device lease service: DD 01-99 per business.
+ * Backend authority: POST /businesses/:id/devices/lease
+ * KV persists device_number per businessId.
+ */
+declare function getAppInstanceId(): string;
+export declare function getDeviceNumber(businessId: string): string | null;
+export declare function isOnlineOnly(businessId: string): boolean;
+export declare function ensureLease(businessId: string): Promise<string | null>;
+export declare function refreshLease(businessId: string): Promise<void>;
+export declare function clearLeaseForTests(businessId: string): void;
+export declare const deviceLeaseService: {
+    getDeviceNumber: typeof getDeviceNumber;
+    isOnlineOnly: typeof isOnlineOnly;
+    ensureLease: typeof ensureLease;
+    refreshLease: typeof refreshLease;
+    getAppInstanceId: typeof getAppInstanceId;
+};
+export {};

package/dist/sync/device-lease.service.js

@@ -0,0 +1,90 @@
+/**
+ * Device lease service: DD 01-99 per business.
+ * Backend authority: POST /businesses/:id/devices/lease
+ * KV persists device_number per businessId.
+ */
+import { getItemSync as getSync, setItemSync as setSync } from "../adapters/kv";
+import { getHttpClient } from "../adapters/http";
+import { generateUUID } from "../utils/uuid";
+import { syncLogger } from "../utils/sync-logger";
+const LEASE_KEY = (businessId) => `teinc_device_number:${businessId}`;
+const LEASE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+function getAppInstanceId() {
+    let id = getSync("teinc_app_instance_id");
+    if (!id) {
+        id = generateUUID();
+        setSync("teinc_app_instance_id", id);
+    }
+    return id;
+}
+export function getDeviceNumber(businessId) {
+    const v = getSync(LEASE_KEY(businessId));
+    if (v && /^(0[1-9]|[1-9][0-9])$/.test(v))
+        return v;
+    return null;
+}
+export function isOnlineOnly(businessId) {
+    return getDeviceNumber(businessId) == null;
+}
+export async function ensureLease(businessId) {
+    const existing = getDeviceNumber(businessId);
+    if (existing)
+        return existing;
+    try {
+        const http = getHttpClient();
+        const deviceUuid = getAppInstanceId();
+        const res = await http.post(`/businesses/${businessId}/devices/lease`, { device_uuid: deviceUuid, app_instance_id: deviceUuid });
+        const data = res.data?.data ?? res.data;
+        const dn = data.device_number;
+        if (dn && /^(0[1-9]|[1-9][0-9])$/.test(dn)) {
+            setSync(LEASE_KEY(businessId), dn);
+            setSync(`${LEASE_KEY(businessId)}:leased_at`, new Date().toISOString());
+            syncLogger.info("DeviceLease", "Leased device number", { businessId, device_number: dn });
+            return dn;
+        }
+    }
+    catch (e) {
+        const apiErr = e;
+        if (apiErr?.status === 429 || e?.message?.includes("DEVICE_LIMIT_REACHED")) {
+            syncLogger.warn("DeviceLease", "Device limit reached — online only", { businessId });
+            return null;
+        }
+        syncLogger.warn("DeviceLease", "Lease failed — will operate online-only until next boot", {
+            businessId,
+            error: String(e),
+        });
+    }
+    return null;
+}
+export async function refreshLease(businessId) {
+    const dn = getDeviceNumber(businessId);
+    if (!dn) {
+        await ensureLease(businessId);
+        return;
+    }
+    const leasedAt = getSync(`${LEASE_KEY(businessId)}:leased_at`);
+    if (leasedAt && Date.now() - new Date(leasedAt).getTime() < LEASE_TTL_MS - 24 * 60 * 60 * 1000) {
+        return;
+    }
+    try {
+        const http = getHttpClient();
+        await http.patch(`/businesses/${businessId}/devices/${getAppInstanceId()}/touch`, {});
+        setSync(`${LEASE_KEY(businessId)}:leased_at`, new Date().toISOString());
+    }
+    catch {
+        // ignore — will retry next boot
+    }
+}
+export function clearLeaseForTests(businessId) {
+    // test helper
+    const { removeItemSync } = require("../adapters/kv");
+    removeItemSync(LEASE_KEY(businessId));
+    removeItemSync(`${LEASE_KEY(businessId)}:leased_at`);
+}
+export const deviceLeaseService = {
+    getDeviceNumber,
+    isOnlineOnly,
+    ensureLease,
+    refreshLease,
+    getAppInstanceId,
+};

package/dist/sync/device-lease.test.d.ts

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

package/dist/sync/device-lease.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { getDeviceNumber, isOnlineOnly } from "./device-lease.service";
+import { removeItemSync, setItemSync } from "../adapters/kv";
+import { setHttpClient } from "../adapters/http";
+describe("device-lease", () => {
+    beforeEach(() => {
+        removeItemSync("teinc_device_number:biz1");
+        removeItemSync("teinc_device_number:biz1:leased_at");
+        removeItemSync("teinc_app_instance_id");
+    });
+    it("returns null when no lease", () => {
+        expect(getDeviceNumber("biz1")).toBeNull();
+        expect(isOnlineOnly("biz1")).toBe(true);
+    });
+    it("returns leased number after set", () => {
+        setItemSync("teinc_device_number:biz1", "05");
+        expect(getDeviceNumber("biz1")).toBe("05");
+        expect(isOnlineOnly("biz1")).toBe(false);
+    });
+    it("rejects invalid DD 00", () => {
+        setItemSync("teinc_device_number:biz1", "00");
+        expect(getDeviceNumber("biz1")).toBeNull();
+    });
+    it("ensureLease handles 429 limit", async () => {
+        // mock http client that returns 429
+        setHttpClient({
+            get: async () => ({ data: null }),
+            post: async () => { throw Object.assign(new Error("DEVICE_LIMIT_REACHED"), { status: 429, name: "ApiError" }); },
+            put: async () => ({ data: null }),
+            patch: async () => ({ data: null }),
+            delete: async () => ({ data: null }),
+        });
+        const { ensureLease } = await import("./device-lease.service");
+        const res = await ensureLease("biz1");
+        expect(res).toBeNull();
+        expect(isOnlineOnly("biz1")).toBe(true);
+    });
+});

package/dist/sync/engine.js

@@ -51,6 +51,27 @@ export class SyncEngine {
      */
     async execute(command) {
         syncLogger.command(command, "issued");
+        // Perms guard (offline-capable): block before routing
+        const { CAPABILITY_BY_COMMAND } = await import("../reference/capabilities");
+        const required = CAPABILITY_BY_COMMAND[command.command_type];
+        if (required) {
+            try {
+                const { getReferenceData } = await import("../reference/operations");
+                const { openSyncDatabase } = await import("../db/connection");
+                const db = await openSyncDatabase();
+                const rec = await getReferenceData(db, command.business_id, "capabilities");
+                const caps = rec?.payload?.data?.capabilities ?? [];
+                // If capabilities cached and missing required, block locally
+                if (rec && caps.length > 0 && !caps.includes(required)) {
+                    throw new ApiError(`Missing capability: ${required}`, 403, "FORBIDDEN");
+                }
+            }
+            catch (e) {
+                if (e instanceof ApiError && e.status === 403)
+                    throw e;
+                // otherwise fail open
+            }
+        }
         let strategy = this.resolveStrategy(command);
         const { isCloudReachable, isOnline } = getConnectivityState();
         syncLogger.info("SyncEngine", "Command strategy resolved", {

package/dist/sync/offline-capable.js

@@ -14,7 +14,26 @@ import { syncEngine } from "./engine";
 import { buildCommand } from "./command-builder";
 import { syncLogger } from "../utils/sync-logger";
 import { ApiError } from "../adapters/http";
+import { CAPABILITY_BY_COMMAND } from "../reference/capabilities";
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData } from "../reference/operations";
 export async function runOfflineCapableMutation(options) {
+    // Per-command capability guard before even attempting direct call
+    const required = CAPABILITY_BY_COMMAND[options.commandType];
+    if (required) {
+        try {
+            const db = await openSyncDatabase();
+            const rec = await getReferenceData(db, options.businessId, "capabilities");
+            const caps = rec?.payload?.data?.capabilities ?? [];
+            if (rec && caps.length > 0 && !caps.includes(required)) {
+                throw new ApiError(`Missing capability: ${required}`, 403, "FORBIDDEN");
+            }
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 403)
+                throw e;
+        }
+    }
     try {
         return await options.run();
     }

package/dist/sync/offline-integration.test.d.ts

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

package/dist/sync/offline-integration.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { generateOrderNumber, resetCalloutForTests } from "./order-number";
+import { removeItemSync, setItemSync } from "../adapters/kv";
+// minimal in-memory DB for outbox
+class MemDB {
+    constructor() {
+        this.commands = [];
+        this.events = [];
+    }
+    async execAsync() { }
+    async runAsync(sql, ...params) {
+        if (sql.includes("INSERT INTO commands")) {
+            this.commands.push({ command_id: params[0], status: params[8] });
+            return { lastInsertRowId: this.commands.length };
+        }
+        if (sql.includes("INSERT INTO events")) {
+            this.events.push({ event_id: params[0] });
+            return { lastInsertRowId: 1 };
+        }
+        if (sql.includes("SELECT * FROM commands WHERE id")) {
+            return null;
+        }
+        return { lastInsertRowId: 1 };
+    }
+    async getFirstAsync() { return null; }
+    async getAllAsync() { return []; }
+}
+describe("offline integration DD-RRR-CCC", () => {
+    beforeEach(() => {
+        removeItemSync("teinc_callout_seq");
+        removeItemSync("teinc_last_random");
+        resetCalloutForTests();
+    });
+    it("queue uses DD-RRR-CCC and survives wrap", () => {
+        setItemSync("teinc_device_number:biz1", "01");
+        // generate two orders
+        const a = generateOrderNumber("01");
+        const b = generateOrderNumber("01");
+        expect(a.orderNumber).toMatch(/^[0-9]{2}-[0-9]{3}-[0-9]{3}$/);
+        expect(b.callout).toBe(a.callout + 1);
+        // ensure per-order random different 100-999
+        expect(a.random).toBeGreaterThanOrEqual(100);
+        expect(b.random).toBeGreaterThanOrEqual(100);
+    });
+    it("offline vs online no difference - order_number adopted", async () => {
+        setItemSync("teinc_callout_seq", 0);
+        const { orderNumber } = generateOrderNumber("05");
+        // backend would adopt this; ensure format
+        expect(orderNumber).toBe("05-" + orderNumber.split("-")[1] + "-" + orderNumber.split("-")[2]);
+        expect(orderNumber.length).toBe(10);
+    });
+});

package/dist/sync/order-number.d.ts

@@ -1,20 +1,24 @@
 /**
- * Local order number allocation for offline/LAN operation.
- *
- * When the cloud is unreachable, the Local Node (or the local device if there
- * is no Local Node) assigns temporary order numbers with the prefix
- * `TFL-YYYYMMDD-NNNN`. These are reconciled with permanent cloud order numbers
- * once connectivity returns.
- */
-/**
- * Generate a local order number for offline-created orders.
- */
-export declare function generateLocalOrderNumber(date?: Date): string;
-/**
- * Generate a local callout number for offline-created orders.
- */
-export declare function generateLocalCalloutNumber(date?: Date): number;
-/**
- * Check whether an order number was locally allocated.
+ * Universal order number: DD-RRR-CCC (10 chars)
+ * DD = device number 01-99 (leased per business)
+ * RRR = random 100-999 per order (crypto)
+ * CCC = callout 001-999 global monotonic per device, wraps to 001 (new RRR on wrap)
+ * Example: "10-123-001"
  */
+export declare function peekCallout(): number;
+export declare function generateOrderNumber(deviceNumber: string): {
+    orderNumber: string;
+    callout: number;
+    random: number;
+};
+export declare function generateLocalOrderNumber(): string;
+export declare function generateOrderNumberForBusiness(businessId: string): string;
+export declare function generateLocalCalloutNumber(): number;
 export declare function isLocalOrderNumber(orderNumber: string): boolean;
+export declare function isOfflineOrderNumber(orderNumber: string): boolean;
+export declare function parseOrderNumber(orderNumber: string): {
+    deviceNumber: string;
+    random: string;
+    callout: string;
+} | null;
+export declare function resetCalloutForTests(): void;

package/dist/sync/order-number.js

@@ -1,53 +1,79 @@
 /**
- * Local order number allocation for offline/LAN operation.
- *
- * When the cloud is unreachable, the Local Node (or the local device if there
- * is no Local Node) assigns temporary order numbers with the prefix
- * `TFL-YYYYMMDD-NNNN`. These are reconciled with permanent cloud order numbers
- * once connectivity returns.
+ * Universal order number: DD-RRR-CCC (10 chars)
+ * DD = device number 01-99 (leased per business)
+ * RRR = random 100-999 per order (crypto)
+ * CCC = callout 001-999 global monotonic per device, wraps to 001 (new RRR on wrap)
+ * Example: "10-123-001"
  */
 import { getItemSync as getItem, setItemSync as setItem } from "../adapters/kv";
-const LOCAL_ORDER_SEQ_KEY = "local_order_sequence";
-const LOCAL_CALLOUT_SEQ_KEY = "local_callout_sequence";
-function formatDatePart(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${year}${month}${day}`;
-}
-function getNextSequence(datePart, key) {
-    const stored = getItem(key);
-    const map = stored ?? {};
-    const next = (map[datePart] ?? 0) + 1;
-    map[datePart] = next;
-    // Keep only the last 7 days to avoid unbounded growth.
-    const cutoff = String(Number(datePart) - 7);
-    for (const mapKey of Object.keys(map)) {
-        if (mapKey < cutoff) {
-            delete map[mapKey];
-        }
+const CALLOUT_SEQ_KEY = "teinc_callout_seq";
+const ORDER_RANDOM_KEY = "teinc_last_random"; // last RRR for wrap logic debug
+function cryptoRandom100to999() {
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+        const arr = new Uint32Array(1);
+        crypto.getRandomValues(arr);
+        return 100 + (arr[0] % 900);
     }
-    setItem(key, map);
+    return 100 + Math.floor(Math.random() * 900);
+}
+function getNextCallout() {
+    const stored = getItem(CALLOUT_SEQ_KEY);
+    let next = (stored ?? 0) + 1;
+    if (next > 999)
+        next = 1;
+    setItem(CALLOUT_SEQ_KEY, next);
     return next;
 }
-/**
- * Generate a local order number for offline-created orders.
- */
-export function generateLocalOrderNumber(date = new Date()) {
-    const datePart = formatDatePart(date);
-    const seq = getNextSequence(datePart, LOCAL_ORDER_SEQ_KEY);
-    return `TFL-${datePart}-${String(seq).padStart(4, "0")}`;
+export function peekCallout() {
+    const stored = getItem(CALLOUT_SEQ_KEY);
+    return stored ?? 0;
 }
-/**
- * Generate a local callout number for offline-created orders.
- */
-export function generateLocalCalloutNumber(date = new Date()) {
-    const datePart = formatDatePart(date);
-    return getNextSequence(datePart, LOCAL_CALLOUT_SEQ_KEY);
+export function generateOrderNumber(deviceNumber) {
+    if (!/^(0[1-9]|[1-9][0-9])$/.test(deviceNumber)) {
+        throw new Error(`Invalid deviceNumber ${deviceNumber} — must be 01-99`);
+    }
+    const callout = getNextCallout();
+    let random = cryptoRandom100to999();
+    // On wrap to 001, ensure new random (already new per order, but keep hook)
+    if (callout === 1) {
+        random = cryptoRandom100to999();
+    }
+    setItem(ORDER_RANDOM_KEY, random);
+    const orderNumber = `${deviceNumber}-${String(random).padStart(3, "0")}-${String(callout).padStart(3, "0")}`;
+    return { orderNumber, callout, random };
 }
-/**
- * Check whether an order number was locally allocated.
- */
+// No legacy fallback — 0.7.0 requires business-scoped device lease via device-lease.service.
+// Kept for internal compat only; callers must supply businessId via generateOrderNumberForBusiness.
+export function generateLocalOrderNumber() {
+    // 0.7.0: do not silently use 99. Throw so caller wires businessId.
+    throw new Error("generateLocalOrderNumber removed in 0.7.0 — use generateOrderNumberForBusiness(businessId)");
+}
+export function generateOrderNumberForBusiness(businessId) {
+    const v = getItem(`teinc_device_number:${businessId}`);
+    if (!v || !/^(0[1-9]|[1-9][0-9])$/.test(v)) {
+        throw new Error(`No device lease for business ${businessId} — call ensureLease(businessId) first (online-only until leased)`);
+    }
+    return generateOrderNumber(v).orderNumber;
+}
+export function generateLocalCalloutNumber() {
+    // kept for SellerOrder.callout_number compatibility — returns CCC
+    const next = peekCallout() + 1;
+    return next > 999 ? 1 : next;
+}
+// New canonical check — unified for DD-RRR-CCC
 export function isLocalOrderNumber(orderNumber) {
-    return orderNumber.startsWith("TFL-");
+    return /^[0-9]{2}-[0-9]{3}-[0-9]{3}$/.test(orderNumber);
+}
+export function isOfflineOrderNumber(orderNumber) {
+    return isLocalOrderNumber(orderNumber);
+}
+export function parseOrderNumber(orderNumber) {
+    const m = orderNumber.match(/^([0-9]{2})-([0-9]{3})-([0-9]{3})$/);
+    if (!m)
+        return null;
+    return { deviceNumber: m[1], random: m[2], callout: m[3] };
+}
+// Test helpers
+export function resetCalloutForTests() {
+    setItem(CALLOUT_SEQ_KEY, 0);
 }

package/dist/sync/order-number.test.js

@@ -1,30 +1,51 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber } from "./order-number";
-import { removeItemSync } from "../adapters/kv";
-// Use in-memory KV for tests (default driver is memory)
-describe("order-number", () => {
+import { generateOrderNumber, isLocalOrderNumber, isOfflineOrderNumber, parseOrderNumber, resetCalloutForTests, } from "./order-number";
+import { removeItemSync, setItemSync } from "../adapters/kv";
+describe("order-number DD-RRR-CCC", () => {
     beforeEach(() => {
-        removeItemSync("local_order_sequence");
-        removeItemSync("local_callout_sequence");
+        removeItemSync("teinc_callout_seq");
+        removeItemSync("teinc_last_random");
+        resetCalloutForTests();
     });
-    it("generates TFL order numbers with date and sequence", () => {
-        const d = new Date("2026-08-24T10:00:00.000Z");
-        const a = generateLocalOrderNumber(d);
-        const b = generateLocalOrderNumber(d);
-        expect(a).toBe("TFL-20260824-0001");
-        expect(b).toBe("TFL-20260824-0002");
-        expect(isLocalOrderNumber(a)).toBe(true);
-        expect(isLocalOrderNumber("KF-260701-0042")).toBe(false);
+    it("generates 10-char DD-RRR-CCC", () => {
+        const { orderNumber, callout } = generateOrderNumber("10");
+        expect(orderNumber).toMatch(/^[0-9]{2}-[0-9]{3}-[0-9]{3}$/);
+        expect(orderNumber.length).toBe(10);
+        expect(callout).toBe(1);
+        expect(isLocalOrderNumber(orderNumber)).toBe(true);
+        expect(isOfflineOrderNumber(orderNumber)).toBe(true);
+        expect(parseOrderNumber(orderNumber)?.deviceNumber).toBe("10");
+    });
+    it("rejects invalid DD 00 and 0a", () => {
+        expect(() => generateOrderNumber("00")).toThrow();
+        expect(() => generateOrderNumber("0a")).toThrow();
+        expect(() => generateOrderNumber("100")).toThrow();
     });
-    it("generates incremental callout numbers per day", () => {
-        const d = new Date("2026-08-24T10:00:00.000Z");
-        expect(generateLocalCalloutNumber(d)).toBe(1);
-        expect(generateLocalCalloutNumber(d)).toBe(2);
+    it("RRR 100-999 and per-order random", () => {
+        const a = generateOrderNumber("01");
+        const b = generateOrderNumber("01");
+        const ra = parseOrderNumber(a.orderNumber).random;
+        const rb = parseOrderNumber(b.orderNumber).random;
+        expect(Number(ra)).toBeGreaterThanOrEqual(100);
+        expect(Number(ra)).toBeLessThanOrEqual(999);
+        // random may collide once, but generally different
+        // at least not all equal across 5
+        const rs = Array.from({ length: 5 }, () => generateOrderNumber("01").random);
+        // all in range
+        for (const r of [a.random, b.random, ...rs])
+            expect(r).toBeGreaterThanOrEqual(100);
     });
-    it("isolates sequences per day", () => {
-        const d1 = new Date("2026-08-24T10:00:00.000Z");
-        const d2 = new Date("2026-08-25T10:00:00.000Z");
-        expect(generateLocalOrderNumber(d1)).toBe("TFL-20260824-0001");
-        expect(generateLocalOrderNumber(d2)).toBe("TFL-20260825-0001");
+    it("CCC wraps 999->001 and new RRR", () => {
+        setItemSync("teinc_callout_seq", 998);
+        const a = generateOrderNumber("10");
+        expect(a.callout).toBe(999);
+        const b = generateOrderNumber("10");
+        expect(b.callout).toBe(1);
+        // both valid format
+        expect(isLocalOrderNumber(b.orderNumber)).toBe(true);
+    });
+    it("isLocalOrderNumber false for legacy", () => {
+        expect(isLocalOrderNumber("TFL-20260824-0001")).toBe(false);
+        expect(isLocalOrderNumber("KF-260701-0042")).toBe(false);
     });
 });

package/dist/sync/perms.test.d.ts

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

package/dist/sync/perms.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { CAPABILITY_BY_COMMAND } from "../reference/capabilities";
+describe("perms guard", () => {
+    it("maps order:create to pos:create_order", () => {
+        expect(CAPABILITY_BY_COMMAND["order:create"]).toBe("pos:create_order");
+        expect(CAPABILITY_BY_COMMAND["menu:update_item"]).toBe("menu:manage");
+    });
+    it("hasCapabilitySyncSync fail open when no cache", async () => {
+        const { hasCapabilitySync } = await import("../reference/capabilities");
+        // without DB, should return true (fail open)
+        // we can't easily test without DB, just ensure it resolves
+        const res = await hasCapabilitySync("biz-no-cache", "order:create");
+        expect(res).toBe(true);
+    });
+});

package/dist/sync/use-device-lease.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 0.7.0 — auto-lease hook. Call once per active business.
+ * Ensures device lease before any offline order is queued.
+ * Apps should call ensureDeviceLease(businessId) after business selection/login.
+ */
+export declare function useDeviceLease(businessId: string | null | undefined): {
+    deviceNumber: string | null;
+    onlineOnly: boolean;
+    loading: boolean;
+};
+export declare function ensureDeviceLease(businessId: string): Promise<string | null>;

package/dist/sync/use-device-lease.js

@@ -0,0 +1,40 @@
+/**
+ * 0.7.0 — auto-lease hook. Call once per active business.
+ * Ensures device lease before any offline order is queued.
+ * Apps should call ensureDeviceLease(businessId) after business selection/login.
+ */
+import { useEffect, useState } from "react";
+import { ensureLease, getDeviceNumber } from "./device-lease.service";
+export function useDeviceLease(businessId) {
+    const [deviceNumber, setDeviceNumber] = useState(null);
+    const [onlineOnly, setOnlineOnly] = useState(false);
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+        if (!businessId)
+            return;
+        let cancelled = false;
+        setLoading(true);
+        const cached = getDeviceNumber(businessId);
+        if (cached) {
+            setDeviceNumber(cached);
+            setOnlineOnly(false);
+            setLoading(false);
+            return;
+        }
+        ensureLease(businessId).then((dn) => {
+            if (cancelled)
+                return;
+            setDeviceNumber(dn);
+            setOnlineOnly(dn == null);
+            setLoading(false);
+        });
+        return () => { cancelled = true; };
+    }, [businessId]);
+    return { deviceNumber, onlineOnly, loading };
+}
+export async function ensureDeviceLease(businessId) {
+    const cached = getDeviceNumber(businessId);
+    if (cached)
+        return cached;
+    return ensureLease(businessId);
+}