@teincfood/core 0.7.9 → 0.8.1

package/dist/db/operations.js

@@ -126,12 +126,22 @@ export async function upsertEntitySnapshot(db, input) {
         last_event_timestamp = excluded.last_event_timestamp,
         payload = excluded.payload;
     `, entityType, entityId, businessId, lastEventId, lastEventTimestamp, JSON.stringify(payload));
+    notifyDbChange(businessId ?? undefined, `entity_snapshots:${entityType}`);
 }
-export async function getEntitySnapshot(db, entityType, entityId) {
+export async function getEntitySnapshot(db, entityType, entityId, businessId) {
+    if (businessId) {
+        const row = await db.getFirstAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id = ? AND business_id = ?;", entityType, entityId, businessId);
+        if (row)
+            return rowToEntitySnapshot(row);
+    }
     const row = await db.getFirstAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id = ?;", entityType, entityId);
     return row ? rowToEntitySnapshot(row) : null;
 }
-export async function getEntitySnapshotsByType(db, entityType) {
+export async function getEntitySnapshotsByType(db, entityType, businessId) {
+    if (businessId) {
+        const rows = await db.getAllAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? AND business_id = ? ORDER BY last_event_timestamp DESC;", entityType, businessId);
+        return rows.map(rowToEntitySnapshot);
+    }
     const rows = await db.getAllAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? ORDER BY last_event_timestamp DESC;", entityType);
     return rows.map(rowToEntitySnapshot);
 }
@@ -173,20 +183,179 @@ function rowToDomainEvent(row) {
         timestamp: row.timestamp,
     };
 }
+function orderRowToSellerOrder(row) {
+    return {
+        id: row.id,
+        business_id: row.business_id,
+        order_number: row.order_number,
+        callout_number: row.callout_number,
+        status: row.status,
+        order_type: row.order_type,
+        is_pos: !!row.is_pos,
+        items: row.items ? JSON.parse(row.items) : [],
+        subtotal_minor: row.subtotal_minor,
+        total_minor: row.total_minor,
+        tax_minor: row.tax_minor,
+        tax_lines: row.tax_lines ? JSON.parse(row.tax_lines) : [],
+        payment: row.payment ? JSON.parse(row.payment) : { is_paid: false, reference: null, amount_minor: null, currency: null, paid_at: null },
+        customer_name: row.customer_name,
+        customer_phone: row.customer_phone,
+        pos_payment_method: row.pos_payment_method,
+        delivery_id: row.delivery_id,
+        business: row.business ? JSON.parse(row.business) : null,
+        delivery_address: null,
+        delivery_lat: null,
+        delivery_lng: null,
+        user: row.user ? JSON.parse(row.user) : null,
+        currency: (row.payment ? JSON.parse(row.payment).currency : "GHS") ?? "GHS",
+        currency_code: (row.payment ? JSON.parse(row.payment).currency : "GHS") ?? "GHS",
+        discount_minor: 0,
+        promo_code: null,
+        tip_minor: null,
+        delivery_fee_minor: 0,
+        delivery_status: null,
+        is_paid: row.payment ? JSON.parse(row.payment).is_paid ?? false : false,
+        paid_at: row.payment ? JSON.parse(row.payment).paid_at ?? null : null,
+        inserted_at: row.inserted_at,
+        updated_at: row.updated_at ?? row.inserted_at,
+    };
+}
+export async function insertOrder(db, order) {
+    const hlc = order.hlc ?? new Date().toISOString();
+    const updatedAt = order.updated_at ?? order.inserted_at;
+    await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET business_id=excluded.business_id, order_number=excluded.order_number, callout_number=excluded.callout_number, status=excluded.status, order_type=excluded.order_type, is_pos=excluded.is_pos, items=excluded.items, subtotal_minor=excluded.subtotal_minor, total_minor=excluded.total_minor, tax_minor=excluded.tax_minor, tax_lines=excluded.tax_lines, payment=excluded.payment, customer_name=excluded.customer_name, customer_phone=excluded.customer_phone, pos_payment_method=excluded.pos_payment_method, delivery_id=excluded.delivery_id, business=excluded.business, user=excluded.user, updated_at=excluded.updated_at, hlc=excluded.hlc
+     WHERE excluded.hlc >= orders.hlc OR orders.hlc IS NULL;`, order.id, order.business_id, order.order_number, order.callout_number, order.status, order.order_type, order.is_pos ? 1 : 0, JSON.stringify(order.items), order.subtotal_minor, order.total_minor, order.tax_minor, JSON.stringify(order.tax_lines), JSON.stringify(order.payment), order.customer_name, order.customer_phone, order.pos_payment_method, order.delivery_id, order.business ? JSON.stringify(order.business) : null, order.user ? JSON.stringify(order.user) : null, order.inserted_at, updatedAt, hlc);
+    notifyDbChange(order.business_id, "orders");
+}
+export async function getOrderById(db, businessId, idOrNumber) {
+    const row = await db.getFirstAsync(`SELECT * FROM orders WHERE business_id = ? AND (id = ? OR order_number = ?) LIMIT 1;`, businessId, idOrNumber, idOrNumber);
+    return row ? orderRowToSellerOrder(row) : null;
+}
+export async function listOrders(db, businessId, filters, page = 1, pageSize = 20) {
+    const where = ["business_id = ?"];
+    const args = [businessId];
+    if (filters?.status) {
+        const statuses = filters.status.split(",").map((s) => s.trim()).filter(Boolean);
+        if (statuses.length) {
+            where.push(`status IN (${statuses.map(() => "?").join(",")})`);
+            args.push(...statuses);
+        }
+    }
+    if (filters?.is_pos != null) {
+        where.push("is_pos = ?");
+        args.push(filters.is_pos === "true" || filters.is_pos === "1" ? 1 : 0);
+    }
+    if (filters?.order_type) {
+        where.push("order_type = ?");
+        args.push(filters.order_type);
+    }
+    if (filters?.q) {
+        where.push("(order_number LIKE ? OR customer_name LIKE ? OR customer_phone LIKE ?)");
+        const q = `%${filters.q}%`;
+        args.push(q, q, q);
+    }
+    if (filters?.date_from) {
+        where.push("inserted_at >= ?");
+        args.push(filters.date_from);
+    }
+    if (filters?.date_to) {
+        where.push("inserted_at < ?");
+        args.push(`${filters.date_to}T23:59:59`);
+    }
+    const whereSql = where.join(" AND ");
+    const countRow = await db.getFirstAsync(`SELECT COUNT(*) as c FROM orders WHERE ${whereSql};`, ...args);
+    const total = countRow?.c ?? 0;
+    const offset = (page - 1) * pageSize;
+    const rows = await db.getAllAsync(`SELECT * FROM orders WHERE ${whereSql} ORDER BY inserted_at DESC LIMIT ? OFFSET ?;`, ...args, pageSize, offset);
+    return { data: rows.map(orderRowToSellerOrder), total };
+}
+export async function updateOrderStatus(db, businessId, orderId, toStatus, hlc) {
+    const now = hlc ?? new Date().toISOString();
+    await db.runAsync(`UPDATE orders SET status = ?, hlc = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, toStatus, now, businessId, orderId, orderId);
+    notifyDbChange(businessId, "orders");
+}
+export async function updateOrderPayment(db, businessId, orderId, patch) {
+    const row = await getOrderById(db, businessId, orderId);
+    if (!row)
+        return;
+    const payment = { ...row.payment, is_paid: patch.is_paid, paid_at: patch.paid_at };
+    await db.runAsync(`UPDATE orders SET payment = ?, hlc = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, JSON.stringify(payment), new Date().toISOString(), businessId, orderId, orderId);
+    notifyDbChange(businessId, "orders");
+}
 // ─────────────────────────────────────────────────────────────
 // Maintenance — clear stale local data (used by Diagnostics)
 // ─────────────────────────────────────────────────────────────
 export async function clearAllSyncData(db) {
-    await db.execAsync(`DELETE FROM commands;`);
-    await db.execAsync(`DELETE FROM events;`);
-    await db.execAsync(`DELETE FROM entity_snapshots;`);
-    // Keep reference_data — it is business-scoped and expensive to re-fetch;
-    // only order/command state is cleared. If full wipe needed, call
-    // clearReferenceData below.
+    // New-DB primary: orders + sync_jobs. Keep legacy deletes guarded (v8 dropped them).
+    try {
+        await db.execAsync(`DELETE FROM orders;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM sync_jobs;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM entity_snapshots;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM commands;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM events;`);
+    }
+    catch { }
+    // Keep reference_data by default (expensive to re-fetch). Use wipeForNewInstall for full reset.
+}
+export async function wipeForNewInstall(db) {
+    try {
+        await db.execAsync(`DELETE FROM orders;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM sync_jobs;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM entity_snapshots;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM reference_data;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM commands;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM events;`);
+    }
+    catch { }
+    try {
+        await db.execAsync(`DELETE FROM migrations WHERE version >= 5;`);
+    }
+    catch { }
 }
 export async function clearReferenceData(db) {
     await db.execAsync(`DELETE FROM reference_data;`);
 }
+const dbChangeListeners = new Set();
+export function subscribeDbChanges(listener) {
+    dbChangeListeners.add(listener);
+    return () => dbChangeListeners.delete(listener);
+}
+export function notifyDbChange(businessId, table) {
+    for (const l of dbChangeListeners)
+        try {
+            l({ businessId, table });
+        }
+        catch { }
+}
 export async function clearCompletedCommandsAndOrphans(db) {
     await db.execAsync(`DELETE FROM commands WHERE status = 'completed';`);
     try {

package/dist/domain/business/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Business — active business isolation (§8), capabilities, profile.
+ */
+export * from "../../adapters/business";
+export * from "../../reference/capabilities";

package/dist/domain/business/index.js

@@ -0,0 +1,5 @@
+/**
+ * Business — active business isolation (§8), capabilities, profile.
+ */
+export * from "../../adapters/business";
+export * from "../../reference/capabilities";

package/dist/domain/orders/lifecycle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Food order lifecycle — explicit transitions, payment independent (§19).
+ * Single source: src/utils/order-transitions. Re-export for domain structure.
+ */
+export * from "../../utils/order-transitions";
+export { orderRepository } from "../../repositories/order.repository";

package/dist/domain/orders/lifecycle.js

@@ -0,0 +1,6 @@
+/**
+ * Food order lifecycle — explicit transitions, payment independent (§19).
+ * Single source: src/utils/order-transitions. Re-export for domain structure.
+ */
+export * from "../../utils/order-transitions";
+export { orderRepository } from "../../repositories/order.repository";

package/dist/domain/orders/service.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Local Orders Service — SQLite is real DB (like backend Orders).
+ * Device-partitioned by UUID PK + DD-RRR-CCC per business.
+ * is_pos orders are accepted at create; online payment requires online.
+ */
+import type { SellerOrder } from "../../types/api/seller.api";
+import type { POSOrderCreateRequest } from "../../types/pos.types";
+export declare function createLocalOrder(businessId: string, input: POSOrderCreateRequest & {
+    is_pos?: boolean;
+    delivery_params?: Record<string, unknown>;
+}): Promise<SellerOrder>;
+export declare function transitionLocalOrder(businessId: string, orderId: string, action: string): Promise<SellerOrder>;
+export declare function listLocalOrders(businessId: string, filters?: {
+    status?: string;
+    q?: string;
+    is_pos?: string;
+    order_type?: string;
+    date_from?: string;
+    date_to?: string;
+}, page?: number, pageSize?: number): Promise<{
+    data: import("../../types/api/seller.api").SellerOrder[];
+    total: number;
+}>;
+export declare function getLocalOrder(businessId: string, idOrNumber: string): Promise<SellerOrder | null>;

package/dist/domain/orders/service.js

@@ -0,0 +1,242 @@
+/**
+ * Local Orders Service — SQLite is real DB (like backend Orders).
+ * Device-partitioned by UUID PK + DD-RRR-CCC per business.
+ * is_pos orders are accepted at create; online payment requires online.
+ */
+import { openSyncDatabase } from "../../db/connection";
+import { insertOrder, getOrderById, listOrders, updateOrderStatus, updateOrderPayment, getEntitySnapshotsByType } from "../../db/operations";
+import { getDeviceNumber, ensureLease } from "../../sync/device-lease.service";
+import { generateOrderNumberForBusiness } from "../../sync/order-number";
+import { generateUUID } from "../../utils/uuid";
+import { getConnectivityState } from "../../adapters/connectivity";
+import { assertOnlineFor } from "../../sync/online-gates";
+import { assertBusinessOpenForCreate } from "../../utils/business-hours";
+import { canTransition } from "../../utils/order-transitions";
+import { validateOrderCreateInput } from "../../validation/offline";
+import { drainOne, pullRemoteOrders } from "../../sync/sync-jobs.service";
+import { getAuthToken } from "../../adapters/auth";
+import { syncLogger } from "../../utils/sync-logger";
+import { getItem } from "../../adapters/kv";
+let backfilled = new Set();
+async function ensureOrdersBackfilledFromSnapshots(businessId) {
+    if (backfilled.has(businessId))
+        return;
+    try {
+        const db = await openSyncDatabase();
+        const cnt = await db.getFirstAsync(`SELECT COUNT(*) as c FROM orders WHERE business_id=?;`, businessId);
+        if ((cnt?.c ?? 0) > 0) {
+            backfilled.add(businessId);
+            return;
+        }
+        const snaps = await getEntitySnapshotsByType(db, "seller_orders", businessId);
+        if (!snaps.length) {
+            backfilled.add(businessId);
+            return;
+        }
+        const seen = new Set();
+        for (const s of snaps) {
+            const arr = s.payload?.data ?? [];
+            for (const o of arr) {
+                if (!o?.id || !o.order_number || seen.has(o.id))
+                    continue;
+                seen.add(o.id);
+                try {
+                    await insertOrder(db, o);
+                }
+                catch { }
+            }
+        }
+        if (seen.size > 0) {
+            try {
+                console.debug("[core] backfilled orders from seller_orders snapshots", { businessId, count: seen.size });
+            }
+            catch { }
+        }
+        backfilled.add(businessId);
+    }
+    catch { }
+}
+function isEffectivelyOnline() {
+    const s = getConnectivityState();
+    // Health probe failure means backend unreachable — treat as offline for order gates too
+    return s.isOnline && s.isCloudReachable !== "unreachable";
+}
+function isOnline() {
+    return isEffectivelyOnline();
+}
+export async function createLocalOrder(businessId, input) {
+    const isPos = true; // POS terminal always is_pos
+    // Online-required gates (single source: sync/online-gates). Cash needs no
+    // connectivity; prepaid/mobile-money and delivery do.
+    assertOnlineFor("order:create", input);
+    // Offline validation mirror — backend Order.changeset rules, pre-commit.
+    validateOrderCreateInput(input);
+    const method = input.pos_payment_method ?? "cash";
+    // Operating-hours gate (fail-closed, offline-first): matches backend
+    // validate_business_open. Throws BUSINESS_CLOSED / HOURS_NOT_SYNCED before
+    // anything is written, so a doomed order never enters SQLite/sync_jobs.
+    await assertBusinessOpenForCreate(businessId);
+    // DD lease required (backend lease, not local alloc) — keep leased DD even offline
+    let dd = getDeviceNumber(businessId);
+    if (!dd) {
+        // Boot race: sync KV may not yet have hydrated from kv.json — try async before blocking
+        try {
+            const asyncDd = await getItem(`teinc_device_number:${businessId}`);
+            if (asyncDd && /^(0[1-9]|[1-9][0-9])$/.test(asyncDd))
+                dd = asyncDd;
+        }
+        catch { }
+    }
+    if (!dd) {
+        const leased = await ensureLease(businessId);
+        if (leased)
+            dd = leased;
+    }
+    if (!dd)
+        throw new Error("No device number leased (99 max) — connect online once to lease DD");
+    const id = (input.id ?? input.command_id ?? generateUUID());
+    const orderNumber = input.order_number?.toString() ?? generateOrderNumberForBusiness(businessId);
+    const callout = parseInt(orderNumber.split("-")[2] ?? "0", 10) || 0;
+    // Use client-provided timestamps for offline-first sync so records created
+    // while offline retain their original creation time.
+    const now = new Date().toISOString();
+    const insertedAt = input.inserted_at || now;
+    // item_snapshots from CartPanel, else fallback
+    const snapshots = input.item_snapshots;
+    const items = snapshots ? snapshots.map((s, i) => ({ id: `tmp-${id}-${i}`, menu_item: { id: s.menu_item_id, name: s.name }, quantity: s.quantity, unit_price: s.unit_price_minor, subtotal: s.unit_price_minor * s.quantity })) : (input.items ?? []).map((it, i) => ({ id: `tmp-${id}-${i}`, menu_item: { id: it.menu_item_id, name: "" }, quantity: it.quantity, unit_price: 0, subtotal: 0 }));
+    const totalMinor = input.total_minor ?? 0;
+    const subtotalMinor = input.subtotal_minor ?? totalMinor;
+    const taxMinor = input.tax_minor ?? 0;
+    const taxLines = input.tax_lines ?? [];
+    const currencyCode = input.currency_code ?? "GHS";
+    const order = {
+        id,
+        order_number: orderNumber,
+        callout_number: callout,
+        status: isPos ? "accepted" : "pending",
+        order_type: input.order_type ?? "takeout",
+        is_pos: isPos,
+        customer_name: input.customer_name ?? null,
+        customer_phone: input.customer_phone ?? null,
+        pos_payment_method: method,
+        paid_at: method === "cash" ? insertedAt : null,
+        is_paid: method === "cash",
+        payment: { is_paid: method === "cash", reference: null, amount_minor: totalMinor, currency: currencyCode, paid_at: method === "cash" ? insertedAt : null },
+        payment_mode: method === "cash" ? "pos_cash" : "prepaid",
+        total_minor: totalMinor,
+        subtotal_minor: subtotalMinor,
+        delivery_fee_minor: input.delivery_fee_minor ?? 0,
+        tax_minor: taxMinor,
+        tip_minor: null,
+        discount_minor: 0,
+        promo_code: null,
+        tax_lines: taxLines,
+        currency: currencyCode,
+        currency_code: currencyCode,
+        business_id: businessId,
+        business: null,
+        delivery_address: null,
+        delivery_lat: null,
+        delivery_lng: null,
+        delivery_id: null,
+        delivery_status: null,
+        user: null,
+        items: items,
+        inserted_at: insertedAt,
+    };
+    const db = await openSyncDatabase();
+    await insertOrder(db, order);
+    syncLogger.debug("DomainOrders", "createLocalOrder inserted", { businessId, id, orderNumber, isPos, connectivity: getConnectivityState(), hasToken: !!getAuthToken(), deviceNumber: dd });
+    try {
+        await db.runAsync(`INSERT OR IGNORE INTO sync_jobs (id, business_id, command_type, entity_id, payload, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?);`, id, businessId, "order:create", id, JSON.stringify({ ...input, order_number: orderNumber, id }), now, now);
+        syncLogger.debug("DomainOrders", "sync_jobs enqueued", { businessId, id, command_type: "order:create" });
+    }
+    catch (e) {
+        syncLogger.debug("DomainOrders", "sync_jobs enqueue fail", { err: String(e) });
+    }
+    syncLogger.debug("DomainOrders", "createLocalOrder triggering drainOne", { businessId, id });
+    void drainOne(businessId, id).catch((e) => syncLogger.debug("DomainOrders", "drainOne after create caught", { err: String(e) }));
+    return order;
+}
+export async function transitionLocalOrder(businessId, orderId, action) {
+    const db = await openSyncDatabase();
+    const order = await getOrderById(db, businessId, orderId);
+    if (!order)
+        throw new Error("Order not found");
+    // Delivery transitions require online (single source: sync/online-gates).
+    if (action === "assign_rider")
+        assertOnlineFor("order:assign_rider");
+    else if (action === "confirm_handover")
+        assertOnlineFor("order:confirm_handover");
+    else if (order.order_type === "delivery")
+        assertOnlineFor("order:create", { order_type: "delivery" });
+    if (!canTransition(order, action)) {
+        throw new Error(`Cannot ${action} from ${order.status}`);
+    }
+    const map = { accept: "accepted", reject: "cancelled", start_preparing: "preparing", mark_ready: "ready", complete_pickup: "delivered", cancel: "cancelled", assign_rider: "assigned", confirm_handover: "delivered", confirm_cash: order.status, pay: order.status };
+    const toStatus = map[action] ?? order.status;
+    if (action === "confirm_cash" || action === "pay") {
+        await updateOrderPayment(db, businessId, orderId, { is_paid: true, paid_at: new Date().toISOString() });
+    }
+    else if (toStatus !== order.status) {
+        await updateOrderStatus(db, businessId, orderId, toStatus);
+    }
+    try {
+        const now = new Date().toISOString();
+        const jobId = generateUUID();
+        await db.runAsync(`INSERT OR IGNORE INTO sync_jobs (id, business_id, command_type, entity_id, payload, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?);`, jobId, businessId, `order:${action}`, orderId, JSON.stringify({ action, orderId }), now, now);
+        syncLogger.debug("DomainOrders", "transition sync_jobs enqueued", { businessId, orderId, action, jobId });
+        void drainOne(businessId, orderId).catch((e) => syncLogger.debug("DomainOrders", "drainOne after transition caught", { err: String(e) }));
+    }
+    catch (e) {
+        syncLogger.debug("DomainOrders", "transition enqueue fail", { err: String(e) });
+    }
+    const updated = await getOrderById(db, businessId, orderId);
+    syncLogger.debug("DomainOrders", "transitionLocalOrder done", { businessId, orderId, action, from: order.status, to: updated?.status });
+    return updated ?? order;
+}
+export async function listLocalOrders(businessId, filters, page = 1, pageSize = 20) {
+    await ensureOrdersBackfilledFromSnapshots(businessId);
+    const db = await openSyncDatabase();
+    const res = await listOrders(db, businessId, filters, page, pageSize);
+    if (res.total === 0) {
+        // blank-screen: snapshot fallback already tried — if still empty and online, fetch from cloud now so listing populates without manual refresh
+        if (isOnline() && getAuthToken()) {
+            try {
+                await pullRemoteOrders(businessId);
+            }
+            catch { }
+            const afterPull = await listOrders(db, businessId, filters, page, pageSize);
+            if (afterPull.total > 0)
+                return afterPull;
+        }
+        // filtered miss — still try backfill re-read
+        if (!filters || Object.keys(filters).length === 0) {
+            await ensureOrdersBackfilledFromSnapshots(businessId);
+            if (backfilled.has(businessId)) {
+                const retry = await listOrders(db, businessId, filters, page, pageSize);
+                if (retry.total > 0)
+                    return retry;
+            }
+        }
+    }
+    return res;
+}
+export async function getLocalOrder(businessId, idOrNumber) {
+    await ensureOrdersBackfilledFromSnapshots(businessId);
+    const db = await openSyncDatabase();
+    const found = await getOrderById(db, businessId, idOrNumber);
+    if (found)
+        return found;
+    // fallback to snapshots for direct link before cloud pull
+    try {
+        const snaps = await getEntitySnapshotsByType(db, "seller_orders", businessId);
+        for (const s of snaps) {
+            const hit = s.payload?.data?.find((o) => o.id === idOrNumber || o.order_number === idOrNumber);
+            if (hit)
+                return hit;
+        }
+    }
+    catch { }
+    return null;
+}

package/dist/domain/payments/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Payments — is_paid independent of status (§19).
+ * Payment events patch only is_paid/paid_at/payment.is_paid.
+ */
+export { orderRepository } from "../../repositories/order.repository";
+export type { SellerOrder } from "../../types/api/seller.api";

package/dist/domain/payments/index.js

@@ -0,0 +1,5 @@
+/**
+ * Payments — is_paid independent of status (§19).
+ * Payment events patch only is_paid/paid_at/payment.is_paid.
+ */
+export { orderRepository } from "../../repositories/order.repository";

package/dist/domain/reference/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference data — per-key last-HLC (§11), Food-specific.
+ */
+export * from "../../reference/operations";
+export * from "../../reference/service";
+export * from "../../reference/api";
+export * from "../../reference/events";
+export * from "../../reference/capabilities";

package/dist/domain/reference/index.js

@@ -0,0 +1,8 @@
+/**
+ * Reference data — per-key last-HLC (§11), Food-specific.
+ */
+export * from "../../reference/operations";
+export * from "../../reference/service";
+export * from "../../reference/api";
+export * from "../../reference/events";
+export * from "../../reference/capabilities";

package/dist/e2e/harness.d.ts

@@ -0,0 +1 @@
+export declare function resetHarness(businessId?: string): Promise<string>;

package/dist/e2e/harness.js

@@ -0,0 +1,61 @@
+/**
+ * E2E harness — real SQLite (memory), real SyncEngine, real command queue, real event journal.
+ * Mock cloud transport in-memory to simulate backend idempotency and Phoenix business:{id}.
+ */
+import { createMemoryDriver } from "../test-helpers/memory-driver";
+import { setSqliteDriver } from "../adapters/sqlite";
+import { closeSyncDatabase, openSyncDatabase } from "../db/connection";
+import { setActiveBusiness } from "../adapters/business";
+import { setConnectivityState } from "../adapters/connectivity";
+import { setHttpClient } from "../adapters/http";
+import { setItemSync } from "../adapters/kv";
+import { hydratePendingOrders, applyPendingOrderEvent, applyOrderStateChangeEvent } from "../sync/pending-orders.service";
+import { usePendingOrdersStore } from "../adapters/pending-orders";
+import { syncEngine } from "../sync/engine";
+import { setAuthProvider } from "../adapters/auth";
+import { seedOpenHours } from "../test-helpers/seed-hours";
+/** NOTE: the engine mock transport is retired with the single create path.
+ * E2E tests mock the HTTP client directly (see core.e2e.test.ts) because
+ * creation flows through createLocalOrder → sync_jobs → REST. */
+let subscribed = false;
+export async function resetHarness(businessId = "biz-e2e") {
+    const driver = createMemoryDriver();
+    setSqliteDriver(driver);
+    try {
+        await closeSyncDatabase();
+    }
+    catch { }
+    await openSyncDatabase();
+    setActiveBusiness({ id: businessId });
+    setConnectivityState({ isOnline: true, isCloudReachable: "reachable" });
+    setItemSync(`teinc_device_number:${businessId}`, "07");
+    // ensure restTransport isAvailable (needs http client)
+    setHttpClient({
+        get: async () => ({ data: [] }),
+        post: async () => ({ data: {} }),
+        put: async () => ({ data: {} }),
+        patch: async () => ({ data: {} }),
+        delete: async () => ({ data: {} }),
+    });
+    // reset callout
+    setItemSync("teinc_callout_seq", 0);
+    setItemSync("teinc_callout_seq:biz-e2e", 0);
+    setItemSync("teinc_callout_seq:biz-A", 0);
+    setItemSync("teinc_callout_seq:biz-B", 0);
+    try {
+        setAuthProvider(() => "token-e2e");
+    }
+    catch { }
+    // Creation is fail-closed on operating hours — seed 24/7 so e2e creates pass.
+    await seedOpenHours(businessId).catch(() => { });
+    usePendingOrdersStore.setState({ orders: [], hydrated: false });
+    if (!subscribed) {
+        subscribed = true;
+        syncEngine.subscribe((evt) => {
+            void applyPendingOrderEvent(evt, "local");
+            void applyOrderStateChangeEvent(evt, "local");
+        });
+    }
+    await hydratePendingOrders().catch(() => { });
+    return businessId;
+}

package/dist/hooks/analytics.hooks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Seller analytics hooks — single source for both apps.
+ * Offline-first: local SQLite aggregates serve instantly; the network
+ * refreshes silently when online.
+ */
+export declare const SELLER_ANALYTICS_KEYS: {
+    all: readonly ["seller-analytics"];
+    analytics: (businessId?: string, period?: string) => readonly ["seller-analytics", string | undefined, string | undefined];
+};
+export declare const REVENUE_KEYS: {
+    all: readonly ["revenue-summary"];
+    summary: (businessId?: string, period?: string) => readonly ["revenue-summary", string | undefined, string | undefined];
+};
+export declare function useSellerAnalyticsQuery(period?: "today" | "this_week" | "this_month", enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    data?: {
+        period?: string;
+        revenue_by_day?: unknown[];
+    };
+}, Error>;
+export declare function useRevenueSummaryQuery(period?: "today" | "this_week" | "this_month", enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    data?: {
+        period?: string;
+        by_day?: unknown[];
+    };
+}, Error>;