@teincfood/core 0.1.2 → 0.1.4

package/dist/adapters/image-cache.d.ts

@@ -1,8 +1,14 @@
 /**
  * Image cache stub — no-op in core library.
- * Host apps with file-system access inject real impl.
+ * Host apps with file-system access inject real impl via imageCacheService.
  */
-export declare function cacheImageBatch(_urls: (string | null | undefined)[], _opts?: {
+export declare const imageCacheService: {
+    cacheImageBatch(urls: (string | null | undefined)[], opts?: {
+        skipIfCached?: boolean;
+    }): Promise<string[]>;
+    pruneImageCache(urls: (string | null | undefined)[]): Promise<void>;
+};
+export declare function cacheImageBatch(urls: (string | null | undefined)[], opts?: {
     skipIfCached?: boolean;
 }): Promise<string[]>;
-export declare function pruneImageCache(_urls: (string | null | undefined)[]): Promise<void>;
+export declare function pruneImageCache(urls: (string | null | undefined)[]): Promise<void>;

package/dist/adapters/image-cache.js

@@ -1,8 +1,16 @@
 /**
  * Image cache stub — no-op in core library.
- * Host apps with file-system access inject real impl.
+ * Host apps with file-system access inject real impl via imageCacheService.
  */
-export async function cacheImageBatch(_urls, _opts) {
-    return [];
+export const imageCacheService = {
+    async cacheImageBatch() {
+        return [];
+    },
+    async pruneImageCache() { },
+};
+export async function cacheImageBatch(urls, opts) {
+    return imageCacheService.cacheImageBatch(urls, opts);
+}
+export async function pruneImageCache(urls) {
+    return imageCacheService.pruneImageCache(urls);
 }
-export async function pruneImageCache(_urls) { }

package/dist/adapters/services.d.ts

@@ -36,6 +36,10 @@ export declare const kioskService: {
 export declare const menuService: {
     fetchBusinessMenuItems: (_businessId: string, _page: number) => Promise<unknown>;
     fetchBusinessCategories: (_businessId: string) => Promise<unknown>;
+    createMenuItem: (_businessId: string, _payload: Record<string, unknown>) => Promise<unknown>;
+    updateMenuItem: (_itemId: string, _payload: Record<string, unknown>) => Promise<unknown>;
+    deleteMenuItem: (_itemId: string) => Promise<unknown>;
+    createCategory: (_businessId: string, _payload: Record<string, unknown>) => Promise<unknown>;
 };
 export declare const businessService: {
     fetchBusinessMembers: (_businessId: string) => Promise<unknown>;

package/dist/adapters/services.js

@@ -47,7 +47,7 @@ export const kioskService = {
         notImpl("kioskService.assignKioskOrderToRider");
     },
 };
-// menu.service etc. for reference fallback
+// menu.service etc. for reference fallback + command dispatch
 export const menuService = {
     fetchBusinessMenuItems: async (_businessId, _page) => {
         notImpl("menuService.fetchBusinessMenuItems");
@@ -55,6 +55,18 @@ export const menuService = {
     fetchBusinessCategories: async (_businessId) => {
         notImpl("menuService.fetchBusinessCategories");
     },
+    createMenuItem: async (_businessId, _payload) => {
+        notImpl("menuService.createMenuItem");
+    },
+    updateMenuItem: async (_itemId, _payload) => {
+        notImpl("menuService.updateMenuItem");
+    },
+    deleteMenuItem: async (_itemId) => {
+        notImpl("menuService.deleteMenuItem");
+    },
+    createCategory: async (_businessId, _payload) => {
+        notImpl("menuService.createCategory");
+    },
 };
 export const businessService = {
     fetchBusinessMembers: async (_businessId) => {

package/dist/index.d.ts

@@ -6,30 +6,62 @@
  */
 export * from "./types/api";
 export * from "./types/pos.types";
+export { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./pricing/engine";
+export type { PricingInput, PricingResult } from "./pricing/engine";
 export * from "./utils/constants";
 export * from "./utils/currency";
 export * from "./utils/error";
 export * from "./utils/uuid";
 export * from "./utils/sync-logger";
+export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
+export type { PhoneCountryOption } from "./utils/phone";
+export * from "./utils/formatCurrency";
+export { formatDate, formatRelativeTime } from "./utils/formatDate";
+export * from "./utils/validation";
+export * from "./utils/responsive";
+export * from "./utils/copyToClipBoard";
 export * from "./db/migrations";
+export * from "./db/operations";
 export * as dbOps from "./db/operations";
-export { openSyncDatabase, getSyncDatabase } from "./db/connection";
+export { openSyncDatabase, getSyncDatabase, closeSyncDatabase } from "./db/connection";
 export * from "./sync/types";
-export { SyncEngine } from "./sync/engine";
+export * from "./sync/use-sync-reconciliation";
+export { SyncEngine, syncEngine } from "./sync/engine";
+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 { orderSnapshotsService } from "./sync/order-snapshots.service";
 export * from "./sync/pending-orders.service";
+export { restTransport } from "./sync/transport-rest";
+export * from "./sync/transport-rest";
+export { localNodeTransport } from "./sync/transport-local-node";
+export * from "./sync/transport-local-node";
+export * from "./sync/order-snapshots.service";
+export { hydratePendingOrders, applyPendingOrderEvent, applyOrderStateChangeEvent } from "./sync/pending-orders.service";
+export { runOfflineCapableMutation } from "./sync/offline-capable";
+export type { OfflineCapableOptions } from "./sync/offline-capable";
 export { orderRepository } from "./repositories/order.repository";
+export type { CreateOrderInput, AssignRiderInput, OrderActionInput } from "./repositories/order.repository";
 export { posRepository } from "./repositories/pos.repository";
+export type { POSOrderPreviewInput } from "./repositories/pos.repository";
 export * from "./reference/types";
+export * from "./reference/operations";
+export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher } from "./reference/api";
+export type { ReferenceLocalNodeFetcher } from "./reference/api";
+export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnReconnect, registerReferenceEventEngine, registerReferenceInvalidator } from "./reference/events";
+export * from "./reference/events";
+export * from "./reference/service";
 export { referenceSyncService } from "./reference/service";
 export * from "./adapters/sqlite";
 export * from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
 export * from "./adapters/local-node";
+export * from "./adapters/services";
+export * from "./adapters/devices";
+export * from "./adapters/image-cache";
 import { type SqliteDriver } from "./adapters/sqlite";
 import { type KVDriver } from "./adapters/kv";
 import { type HttpClient } from "./adapters/http";
@@ -38,6 +70,8 @@ export interface CoreConfig {
     sqliteDriver?: SqliteDriver;
     kvDriver?: KVDriver;
     httpClient?: HttpClient;
+    apiBaseUrl?: string;
+    wsBaseUrl?: string;
     /** Optional initial connectivity override */
     initialConnectivity?: {
         isOnline?: boolean;

package/dist/index.js

@@ -7,29 +7,53 @@
 // ── Types ──
 export * from "./types/api";
 export * from "./types/pos.types";
+// ── Pricing (server-parity) ──
+export { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./pricing/engine";
 // ── Utils ──
 export * from "./utils/constants";
 export * from "./utils/currency";
 export * from "./utils/error";
 export * from "./utils/uuid";
 export * from "./utils/sync-logger";
+export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
+export * from "./utils/formatCurrency";
+export { formatDate, formatRelativeTime } from "./utils/formatDate";
+export * from "./utils/validation";
+export * from "./utils/responsive";
+export * from "./utils/copyToClipBoard";
 // ── DB ──
 export * from "./db/migrations";
+export * from "./db/operations";
 export * as dbOps from "./db/operations";
-export { openSyncDatabase, getSyncDatabase } from "./db/connection";
+export { openSyncDatabase, getSyncDatabase, closeSyncDatabase } from "./db/connection";
 // ── Sync ──
 export * from "./sync/types";
-export { SyncEngine } from "./sync/engine";
+export * from "./sync/use-sync-reconciliation";
+export { SyncEngine, syncEngine } from "./sync/engine";
+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 { orderSnapshotsService } from "./sync/order-snapshots.service";
 export * from "./sync/pending-orders.service";
+export { restTransport } from "./sync/transport-rest";
+export * from "./sync/transport-rest";
+export { localNodeTransport } from "./sync/transport-local-node";
+export * from "./sync/transport-local-node";
+export * from "./sync/order-snapshots.service";
+export { hydratePendingOrders, applyPendingOrderEvent, applyOrderStateChangeEvent } from "./sync/pending-orders.service";
+export { runOfflineCapableMutation } from "./sync/offline-capable";
 // ── Repositories ──
 export { orderRepository } from "./repositories/order.repository";
 export { posRepository } from "./repositories/pos.repository";
 // ── Reference ──
 export * from "./reference/types";
+export * from "./reference/operations";
+export { fetchReferenceVersions, fetchReferenceData, fetchReferenceChanges, setReferenceLocalNodeFetcher } from "./reference/api";
+export { emitReferenceChanged, applyReferenceChangeEvent, syncReferenceDataOnReconnect, registerReferenceEventEngine, registerReferenceInvalidator } from "./reference/events";
+export * from "./reference/events";
+export * from "./reference/service";
 export { referenceSyncService } from "./reference/service";
 // ── Adapters (for host apps to supply) ──
 export * from "./adapters/sqlite";
@@ -37,24 +61,60 @@ export * from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
 export * from "./adapters/local-node";
+export * from "./adapters/services";
+export * from "./adapters/devices";
+export * from "./adapters/image-cache";
 // ── Init helper ──
 import { setSqliteDriver } from "./adapters/sqlite";
 import { setKVDriver } from "./adapters/kv";
 import { setConnectivityState } from "./adapters/connectivity";
 import { setHttpClient } from "./adapters/http";
+import { API_BASE_URL, WS_BASE_URL, setApiBaseUrl, setWsBaseUrl } from "./utils/constants";
 import { SyncEngine } from "./sync/engine";
 import { restTransport } from "./sync/transport-rest";
 import { localNodeTransport } from "./sync/transport-local-node";
 let engine = null;
 export function createTeincCore(config = {}) {
+    try {
+        console.debug("[core] createTeincCore called", {
+            hasSqliteDriver: !!config.sqliteDriver,
+            hasKvDriver: !!config.kvDriver,
+            hasHttpClient: !!config.httpClient,
+            apiBaseUrl: config.apiBaseUrl ?? "(default)",
+            wsBaseUrl: config.wsBaseUrl ?? "(default)",
+            initialConnectivity: config.initialConnectivity ?? null,
+        });
+    }
+    catch { }
     if (config.sqliteDriver)
         setSqliteDriver(config.sqliteDriver);
     if (config.kvDriver)
         setKVDriver(config.kvDriver);
     if (config.httpClient)
         setHttpClient(config.httpClient);
+    if (config.apiBaseUrl)
+        setApiBaseUrl(config.apiBaseUrl);
+    else {
+        try {
+            console.debug("[core] apiBaseUrl not provided by app, using default", API_BASE_URL);
+        }
+        catch { }
+    }
+    if (config.wsBaseUrl)
+        setWsBaseUrl(config.wsBaseUrl);
+    else {
+        try {
+            console.debug("[core] wsBaseUrl not provided by app, using default", WS_BASE_URL);
+        }
+        catch { }
+    }
     if (config.initialConnectivity)
         setConnectivityState(config.initialConnectivity);
+    // Debug: confirm env vars as seen by core after injection
+    try {
+        console.debug("[core] final URLs", { API_BASE_URL, WS_BASE_URL });
+    }
+    catch { }
     engine = new SyncEngine({ transports: [restTransport, localNodeTransport] });
     return { engine };
 }

package/dist/pricing/engine.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Pricing engine — server-parity POS pricing.
+ *
+ * Pure port of the backend `calculate_items` / `calculate_tax_lines` /
+ * `calculate_pricing` (TeincFoodBackend.Orders). Used as the instant local
+ * preview and offline fallback so terminals agree on pricing even when the
+ * cloud preview endpoint is unreachable. The cloud preview remains authoritative
+ * when it lands; this engine reproduces the same math exactly.
+ *
+ * Tax semantics (matching backend):
+ *  - inclusive taxes are EMBEDDED in the menu price → never added to the total,
+ *    only shown in `tax_lines[].is_inclusive` for the breakdown.
+ *  - exclusive taxes are ADDED on top of the (discounted) subtotal.
+ *  - `tax_minor` is the sum of ALL lines (display breakdown); `total_minor`
+ *    adds only `exclusive_tax_minor`.
+ */
+import type { POSCartItem } from "../types/pos.types";
+import type { TaxRule } from "../types/api/business.api";
+import type { OrderTaxLine } from "../types/api/seller.api";
+export interface PricingInput {
+    /** Cart items — `unit_price_minor` already includes variant + addons. */
+    items: POSCartItem[];
+    /** Active tax rules from cached reference data. */
+    taxRules: TaxRule[];
+    /** Optional promo discount in minor units. */
+    discount_minor?: number;
+    /** Delivery fee in minor units (POS is 0, but kept for parity). */
+    delivery_fee_minor?: number;
+    /** Tip in minor units. */
+    tip_minor?: number;
+    currency_code?: string;
+}
+export interface PricingResult {
+    subtotal_minor: number;
+    discounted_subtotal_minor: number;
+    delivery_fee_minor: number;
+    discount_minor: number;
+    tax_minor: number;
+    exclusive_tax_minor: number;
+    tip_minor: number;
+    total_minor: number;
+    currency_code: string;
+    tax_lines: OrderTaxLine[];
+}
+/** Backend parity: div((amount * rate + 5000), 10000) with integer math. */
+export declare function calculateExclusiveTax(taxableAmountMinor: number, rateBasisPoints: number): number;
+/** Backend parity: inclusive tax share = div(amount*rate + 5000, 10000 + rate). */
+export declare function calculateInclusiveTaxShare(taxableAmountMinor: number, rateBasisPoints: number): number;
+export declare function calculateTaxLines(subtotal_minor: number, taxRules: TaxRule[], discount_minor?: number, delivery_fee_minor?: number): {
+    tax_lines: OrderTaxLine[];
+    tax_minor: number;
+    exclusive_tax_minor: number;
+};
+/**
+ * Compute POS pricing mirrors backend `calculate_pos_pricing`:
+ *   total = discounted_subtotal + exclusive_tax_minor (+ tip when provided).
+ */
+export declare function calculatePricing(input: PricingInput): PricingResult;

package/dist/pricing/engine.js

@@ -0,0 +1,82 @@
+/**
+ * Pricing engine — server-parity POS pricing.
+ *
+ * Pure port of the backend `calculate_items` / `calculate_tax_lines` /
+ * `calculate_pricing` (TeincFoodBackend.Orders). Used as the instant local
+ * preview and offline fallback so terminals agree on pricing even when the
+ * cloud preview endpoint is unreachable. The cloud preview remains authoritative
+ * when it lands; this engine reproduces the same math exactly.
+ *
+ * Tax semantics (matching backend):
+ *  - inclusive taxes are EMBEDDED in the menu price → never added to the total,
+ *    only shown in `tax_lines[].is_inclusive` for the breakdown.
+ *  - exclusive taxes are ADDED on top of the (discounted) subtotal.
+ *  - `tax_minor` is the sum of ALL lines (display breakdown); `total_minor`
+ *    adds only `exclusive_tax_minor`.
+ */
+/** Backend parity: div((amount * rate + 5000), 10000) with integer math. */
+export function calculateExclusiveTax(taxableAmountMinor, rateBasisPoints) {
+    if (taxableAmountMinor <= 0 || rateBasisPoints <= 0)
+        return 0;
+    return Math.floor((taxableAmountMinor * rateBasisPoints + 5000) / 10000);
+}
+/** Backend parity: inclusive tax share = div(amount*rate + 5000, 10000 + rate). */
+export function calculateInclusiveTaxShare(taxableAmountMinor, rateBasisPoints) {
+    if (taxableAmountMinor <= 0 || rateBasisPoints <= 0)
+        return 0;
+    return Math.floor((taxableAmountMinor * rateBasisPoints + 5000) / (10000 + rateBasisPoints));
+}
+export function calculateTaxLines(subtotal_minor, taxRules, discount_minor = 0, delivery_fee_minor = 0) {
+    const discounted = Math.max(subtotal_minor - discount_minor, 0);
+    let tax_minor = 0;
+    let exclusive_tax_minor = 0;
+    const tax_lines = taxRules.map((rule) => {
+        const taxableAmount = rule.applies_to === "subtotal_plus_delivery"
+            ? discounted + delivery_fee_minor
+            : discounted;
+        const taxAmount = rule.is_inclusive
+            ? calculateInclusiveTaxShare(taxableAmount, rule.rate_basis_points)
+            : calculateExclusiveTax(taxableAmount, rule.rate_basis_points);
+        tax_minor += taxAmount;
+        if (!rule.is_inclusive)
+            exclusive_tax_minor += taxAmount;
+        return {
+            id: rule.id,
+            business_tax_rule_id: rule.id,
+            name: rule.name,
+            code: rule.code,
+            country_code: rule.country_code,
+            rate_basis_points: rule.rate_basis_points,
+            taxable_amount_minor: taxableAmount,
+            tax_amount_minor: taxAmount,
+            applies_to: rule.applies_to,
+            is_inclusive: rule.is_inclusive,
+        };
+    });
+    return { tax_lines, tax_minor, exclusive_tax_minor };
+}
+/**
+ * Compute POS pricing mirrors backend `calculate_pos_pricing`:
+ *   total = discounted_subtotal + exclusive_tax_minor (+ tip when provided).
+ */
+export function calculatePricing(input) {
+    const subtotal_minor = input.items.reduce((sum, item) => sum + item.unit_price_minor * item.quantity, 0);
+    const discount_minor = input.discount_minor ?? 0;
+    const delivery_fee_minor = input.delivery_fee_minor ?? 0;
+    const tip_minor = input.tip_minor ?? 0;
+    const currency_code = input.currency_code ?? "GHS";
+    const { tax_lines, tax_minor, exclusive_tax_minor } = calculateTaxLines(subtotal_minor, input.taxRules, discount_minor, delivery_fee_minor);
+    const discounted = Math.max(subtotal_minor - discount_minor, 0);
+    return {
+        subtotal_minor,
+        discounted_subtotal_minor: discounted,
+        delivery_fee_minor,
+        discount_minor,
+        tax_minor,
+        exclusive_tax_minor,
+        tip_minor,
+        total_minor: discounted + delivery_fee_minor + exclusive_tax_minor + tip_minor,
+        currency_code,
+        tax_lines,
+    };
+}

package/dist/pricing/engine.test.d.ts

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

package/dist/pricing/engine.test.js

@@ -0,0 +1,142 @@
+/**
+ * Server-parity tests for the pricing engine.
+ *
+ * Mirrors the backend ExUnit vectors in
+ * pos_controller_test.exs (inclusive / exclusive / mixed) and the
+ * rounding formulas in Orders.calculate_tax_amount. Golden values below come
+ * directly from the Elixir implementation so the two runtimes never diverge.
+ */
+import { describe, it, expect } from "vitest";
+import { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./engine";
+function cart(unitPriceMinor, quantity = 1, addonsMinor = []) {
+    return [
+        {
+            id: "cart-1",
+            menu_item: {
+                id: "item-1",
+                name: "Test Item",
+                description: null,
+                basePrice: { amountMinor: unitPriceMinor, currencyCode: "GHS" },
+                image_url: null,
+                is_available: true,
+                dietary_tags: [],
+                category_id: "cat-1",
+                business_id: "biz-1",
+                category: null,
+                variants: [],
+                extras: [],
+                inserted_at: "",
+                updated_at: "",
+            },
+            quantity,
+            selected_variant: null,
+            selected_addons: addonsMinor.map((price_minor, i) => ({
+                addon_id: `addon-${i}`,
+                name: `Addon ${i}`,
+                price_minor,
+            })),
+            notes: "",
+            // unit_price_minor already includes variant + addons (matches pos.store)
+            unit_price_minor: unitPriceMinor,
+        },
+    ];
+}
+function taxRule(overrides) {
+    return {
+        id: "tax-1",
+        business_id: "biz-1",
+        country_code: "GH",
+        applies_to: "subtotal",
+        is_inclusive: false,
+        is_active: true,
+        display_order: 0,
+        inserted_at: "",
+        updated_at: "",
+        ...overrides,
+    };
+}
+describe("calculateExclusiveTax / calculateInclusiveTaxShare (backend rounding)", () => {
+    it("computes exclusive tax = floor(amount*rate/10000)", () => {
+        expect(calculateExclusiveTax(2400, 1000)).toBe(240); // 10%
+        expect(calculateExclusiveTax(1200, 1000)).toBe(120);
+        expect(calculateExclusiveTax(2400, 0)).toBe(0);
+        expect(calculateExclusiveTax(0, 1000)).toBe(0);
+    });
+    it("computes inclusive share = floor(amount*rate/(10000+rate))", () => {
+        // Backend: div(2400 * 7500 + 5000, 107500) = 1028
+        expect(calculateInclusiveTaxShare(2400, 7500)).toBe(1028);
+        expect(calculateInclusiveTaxShare(0, 7500)).toBe(0);
+        expect(calculateInclusiveTaxShare(2400, 0)).toBe(0);
+    });
+});
+describe("calculateTaxLines", () => {
+    it("returns exclusive-only additions for exclusive rules", () => {
+        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
+        const { tax_lines, tax_minor, exclusive_tax_minor } = calculateTaxLines(2400, rules);
+        expect(tax_minor).toBe(240);
+        expect(exclusive_tax_minor).toBe(240);
+        expect(tax_lines[0].is_inclusive).toBe(false);
+        expect(tax_lines[0].tax_amount_minor).toBe(240);
+    });
+    it("returns embedded amounts for inclusive rules (not added to total)", () => {
+        const rules = [taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true })];
+        const { tax_lines, tax_minor, exclusive_tax_minor } = calculateTaxLines(2400, rules);
+        expect(tax_minor).toBe(1028); // display share
+        expect(exclusive_tax_minor).toBe(0); // nothing added to total
+        expect(tax_lines[0].is_inclusive).toBe(true);
+        expect(tax_lines[0].tax_amount_minor).toBe(1028);
+    });
+    it("applies tax to discounted subtotal first", () => {
+        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
+        const { exclusive_tax_minor } = calculateTaxLines(2400, rules, 400, 0); // 2000 taxable
+        expect(exclusive_tax_minor).toBe(200);
+    });
+    it("honors applies_to = subtotal_plus_delivery", () => {
+        const rules = [
+            taxRule({ name: "Service", code: "service", rate_basis_points: 1000, applies_to: "subtotal_plus_delivery" }),
+        ];
+        const { exclusive_tax_minor } = calculateTaxLines(2400, rules, 0, 600); // 3000 taxable
+        expect(exclusive_tax_minor).toBe(300);
+    });
+});
+describe("calculatePricing (POS parity with backend)", () => {
+    it("no tax → total == subtotal", () => {
+        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: [], currency_code: "GHS" });
+        expect(pricing.subtotal_minor).toBe(2400);
+        expect(pricing.total_minor).toBe(2400);
+        expect(pricing.exclusive_tax_minor).toBe(0);
+    });
+    it("inclusive-only tax does NOT inflate total (backend vector: 2400 → 2400)", () => {
+        const rules = [taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true })];
+        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
+        expect(pricing.subtotal_minor).toBe(2400);
+        expect(pricing.total_minor).toBe(2400); // NOT 2400 + 168
+        expect(pricing.exclusive_tax_minor).toBe(0);
+        expect(pricing.tax_minor).toBe(1028);
+        expect(pricing.tax_lines).toHaveLength(1);
+        expect(pricing.tax_lines[0].is_inclusive).toBe(true);
+    });
+    it("exclusive tax is added on top (backend vector: 2400 → 2640)", () => {
+        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
+        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
+        expect(pricing.subtotal_minor).toBe(2400);
+        expect(pricing.exclusive_tax_minor).toBe(240);
+        expect(pricing.total_minor).toBe(2640);
+    });
+    it("mixed inclusive + exclusive adds only the exclusive portion (backend vector: 2640)", () => {
+        const rules = [
+            taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true }),
+            taxRule({ name: "Service", code: "service", rate_basis_points: 1000 }),
+        ];
+        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
+        expect(pricing.total_minor).toBe(2640);
+        expect(pricing.exclusive_tax_minor).toBe(240);
+        expect(pricing.tax_minor).toBe(1028 + 240); // display breakdown
+        expect(pricing.tax_lines).toHaveLength(2);
+    });
+    it("applies tips when provided (POS total = subtotal + excl tax + tip)", () => {
+        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
+        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, tip_minor: 500, currency_code: "GHS" });
+        expect(pricing.total_minor).toBe(2400 + 240 + 500);
+    });
+});

package/dist/reference/api.d.ts

@@ -4,7 +4,24 @@
  * These endpoints are expected on the backend. If they are not available,
  * the ReferenceSyncService falls back to legacy menu endpoints.
  */
-import type { ReferenceDataKey, ReferenceVersionInfo, ReferenceChangeSet } from "./types";
+import type { ReferenceDataKey, ReferenceVersionInfo, ReferenceChangeSet, ReferenceDataRecord } from "./types";
+/**
+ * Optional LAN supplier: when the cloud is unreachable (offline + connected to
+ * a Local Node), the host app can serve cached reference data from the node via
+ * the LAN instead of failing. Injected by the host (mobile/desktop) once at
+ * bootstrap; null means no LAN reference path.
+ */
+export type ReferenceLocalNodeFetcher = (options: {
+    businessId: string;
+    keys: ReferenceDataKey[];
+}) => Promise<Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>>;
+export declare function setReferenceLocalNodeFetcher(fetcher: ReferenceLocalNodeFetcher | null): void;
 export declare function fetchReferenceVersions(businessId: string): Promise<ReferenceVersionInfo[]>;
+/**
+ * Fetch reference data for the requested keys. Falls back to the Local Node
+ * (LAN) when the cloud call fails and a LAN fetcher is configured — so a
+ * no-internet terminal can still converge after a `reference_data.changed`
+ * event relayed over the LAN.
+ */
 export declare function fetchReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<Record<ReferenceDataKey, unknown>>;
 export declare function fetchReferenceChanges<T>(businessId: string, key: ReferenceDataKey, fromVersion: string): Promise<ReferenceChangeSet<T>>;

package/dist/reference/api.js

@@ -5,13 +5,36 @@
  * the ReferenceSyncService falls back to legacy menu endpoints.
  */
 import { api } from "../adapters/http";
+let localNodeFetcher = null;
+export function setReferenceLocalNodeFetcher(fetcher) {
+    localNodeFetcher = fetcher;
+}
 export async function fetchReferenceVersions(businessId) {
     const response = await api.get(`/businesses/${businessId}/reference-versions`);
     return response.data.data;
 }
+/**
+ * Fetch reference data for the requested keys. Falls back to the Local Node
+ * (LAN) when the cloud call fails and a LAN fetcher is configured — so a
+ * no-internet terminal can still converge after a `reference_data.changed`
+ * event relayed over the LAN.
+ */
 export async function fetchReferenceData(businessId, keys) {
-    const response = await api.get(`/businesses/${businessId}/reference-data`, { params: { keys: keys.join(",") } });
-    return response.data.data;
+    try {
+        const response = await api.get(`/businesses/${businessId}/reference-data`, { params: { keys: keys.join(",") } });
+        return response.data.data;
+    }
+    catch (error) {
+        if (!localNodeFetcher)
+            throw error;
+        const cached = await localNodeFetcher({ businessId, keys });
+        const out = {};
+        for (const key of keys) {
+            if (cached[key]?.payload != null)
+                out[key] = cached[key].payload;
+        }
+        return out;
+    }
 }
 export async function fetchReferenceChanges(businessId, key, fromVersion) {
     const response = await api.get(`/businesses/${businessId}/reference-changes`, { params: { key, from_version: fromVersion } });

package/dist/sync/offline-capable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Offline-capable mutation runner.
+ *
+ * Wraps a direct REST service call (used by menu edits etc.) so that when the
+ * request fails with a NETWORK error (offline / cloud unreachable), the
+ * operation is retried through the Sync Engine instead — which routes it to
+ * the Local Node, or persists it in the durable outbox for replay when
+ * connectivity returns. Definitive server rejections (4xx) are NOT touched:
+ * they are real business decisions and must surface to the caller.
+ *
+ * Keeps the online path and its result shape unchanged.
+ */
+export interface OfflineCapableOptions<TService, TCommandPayload> {
+    /** Direct REST call — used online. */
+    run: () => Promise<TService>;
+    /** Sync-engine command fallback (Local Node / outbox). */
+    commandType: string;
+    businessId: string;
+    entityId?: string;
+    payload: TCommandPayload;
+}
+export declare function runOfflineCapableMutation<TService, TCommandPayload>(options: OfflineCapableOptions<TService, TCommandPayload>): Promise<TService>;

package/dist/sync/offline-capable.js

@@ -0,0 +1,41 @@
+/**
+ * Offline-capable mutation runner.
+ *
+ * Wraps a direct REST service call (used by menu edits etc.) so that when the
+ * request fails with a NETWORK error (offline / cloud unreachable), the
+ * operation is retried through the Sync Engine instead — which routes it to
+ * the Local Node, or persists it in the durable outbox for replay when
+ * connectivity returns. Definitive server rejections (4xx) are NOT touched:
+ * they are real business decisions and must surface to the caller.
+ *
+ * Keeps the online path and its result shape unchanged.
+ */
+import { syncEngine } from "./engine";
+import { buildCommand } from "./command-builder";
+import { syncLogger } from "../utils/sync-logger";
+import { ApiError } from "../adapters/http";
+export async function runOfflineCapableMutation(options) {
+    try {
+        return await options.run();
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status >= 400 && error.status < 500) {
+            // Definitive rejection — surface it, do not queue.
+            throw error;
+        }
+        // Network error (no response), timeout, or transport failure: route through
+        // the Sync Engine (LAN node → outbox). The engine itself decides.
+        syncLogger.warn("OfflineCapable", "Direct call failed, routing via Sync Engine", {
+            command_type: options.commandType,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        const command = buildCommand({
+            commandType: options.commandType,
+            businessId: options.businessId,
+            entityId: options.entityId,
+            payload: options.payload,
+        });
+        const events = await syncEngine.execute(command);
+        return events[0]?.payload;
+    }
+}

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

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

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

@@ -0,0 +1,30 @@
+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", () => {
+    beforeEach(() => {
+        removeItemSync("local_order_sequence");
+        removeItemSync("local_callout_sequence");
+    });
+    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 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("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");
+    });
+});

package/dist/sync/transport-rest.js

@@ -5,7 +5,7 @@
  * resulting domain events. This transport is used when the cloud API is
  * reachable.
  */
-import { posService, sellerService, kioskService } from "../adapters/services";
+import { posService, sellerService, kioskService, menuService } from "../adapters/services";
 import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
 export class RestTransport {
@@ -88,6 +88,22 @@ export class RestTransport {
                 const response = await sellerService.confirmHandover(entity_id);
                 return this.wrapResponse("delivery.status_changed", response, entity_id, timestamp, command);
             }
+            case "menu:create_item": {
+                const response = await menuService.createMenuItem(business_id, payload);
+                return this.wrapResponse("menu.item_created", response, entity_id, timestamp, command);
+            }
+            case "menu:update_item": {
+                const response = await menuService.updateMenuItem(entity_id, payload);
+                return this.wrapResponse("menu.item_updated", response, entity_id, timestamp, command);
+            }
+            case "menu:delete_item": {
+                const response = await menuService.deleteMenuItem(entity_id);
+                return this.wrapResponse("menu.item_deleted", response, entity_id, timestamp, command);
+            }
+            case "menu:create_category": {
+                const response = await menuService.createCategory(business_id, payload);
+                return this.wrapResponse("menu.category_created", response, entity_id, timestamp, command);
+            }
             default:
                 throw new Error(`RestTransport: unsupported command type ${command_type}`);
         }

package/dist/types/pos.types.d.ts

@@ -59,6 +59,7 @@ export interface POSPricing {
     discounted_subtotal_minor: number;
     delivery_fee_minor: number;
     tax_minor: number;
+    exclusive_tax_minor?: number;
     tip_minor: number;
     discount_minor: number;
     total_minor: number;

package/dist/utils/constants.d.ts

@@ -2,10 +2,12 @@
  * Application-wide constants — plain config, no expo dependencies.
  * Values can be overridden via createTeincCore config (future).
  */
-/** Base URL for the API — will be swapped per environment */
-export declare const API_BASE_URL: string;
-/** WebSocket URL for Phoenix Channels */
-export declare const WS_BASE_URL: string;
+/** Base URL for the API — set at runtime via createTeincCore({ apiBaseUrl }) from the host app's .env */
+export declare let API_BASE_URL: string;
+/** WebSocket URL for Phoenix Channels — set at runtime via createTeincCore({ wsBaseUrl }) */
+export declare let WS_BASE_URL: string;
+export declare function setApiBaseUrl(url: string | undefined): void;
+export declare function setWsBaseUrl(url: string | undefined): void;
 /** App metadata */
 export declare const APP_NAME = "Teinc Food Business";
 export declare const APP_VERSION = "1.0.0";

package/dist/utils/constants.js

@@ -2,14 +2,40 @@
  * Application-wide constants — plain config, no expo dependencies.
  * Values can be overridden via createTeincCore config (future).
  */
-/** Base URL for the API — will be swapped per environment */
-export const API_BASE_URL = process.env.EXPO_PUBLIC_API_URL ??
-    process.env.API_URL ??
-    "http://localhost:4000/api/v1";
-/** WebSocket URL for Phoenix Channels */
-export const WS_BASE_URL = process.env.EXPO_PUBLIC_WS_URL ??
-    process.env.WS_URL ??
-    "ws://localhost:4000";
+/** Base URL for the API — set at runtime via createTeincCore({ apiBaseUrl }) from the host app's .env */
+export let API_BASE_URL = "http://localhost:4000/api/v1";
+/** WebSocket URL for Phoenix Channels — set at runtime via createTeincCore({ wsBaseUrl }) */
+export let WS_BASE_URL = "ws://localhost:4000";
+export function setApiBaseUrl(url) {
+    if (url) {
+        API_BASE_URL = url;
+        try {
+            console.debug("[core:constants] API_BASE_URL set", url);
+        }
+        catch { }
+    }
+    else {
+        try {
+            console.debug("[core:constants] API_BASE_URL using default", API_BASE_URL);
+        }
+        catch { }
+    }
+}
+export function setWsBaseUrl(url) {
+    if (url) {
+        WS_BASE_URL = url;
+        try {
+            console.debug("[core:constants] WS_BASE_URL set", url);
+        }
+        catch { }
+    }
+    else {
+        try {
+            console.debug("[core:constants] WS_BASE_URL using default", WS_BASE_URL);
+        }
+        catch { }
+    }
+}
 /** App metadata */
 export const APP_NAME = "Teinc Food Business";
 export const APP_VERSION = "1.0.0";

package/dist/utils/currency.test.d.ts

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

package/dist/utils/currency.test.js

@@ -0,0 +1,17 @@
+import { describe, it, expect } from "vitest";
+import { formatPrice, formatPriceFromMinor, getCurrencySymbol, DEFAULT_CURRENCY } from "./currency";
+describe("currency", () => {
+    it("returns symbol for known currencies", () => {
+        expect(getCurrencySymbol("GHS")).toBe("GH₵");
+        expect(getCurrencySymbol("USD")).toBe("$");
+        expect(getCurrencySymbol("UNKNOWN")).toBe("UNKNOWN");
+    });
+    it("formats price with default currency", () => {
+        expect(formatPrice(10.5)).toBe(`${getCurrencySymbol(DEFAULT_CURRENCY)}10.50`);
+    });
+    it("formats price from minor units", () => {
+        expect(formatPriceFromMinor(1050, "GHS")).toBe("GH₵10.50");
+        expect(formatPriceFromMinor(100, "USD")).toBe("$1.00");
+        expect(formatPriceFromMinor(0)).toBe(`${getCurrencySymbol(DEFAULT_CURRENCY)}0.00`);
+    });
+});

package/dist/utils/phone.test.d.ts

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

package/dist/utils/phone.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { normalizePhoneForCountry, isLikelyE164, getDialCodeFromCountry } from "./phone";
+describe("phone", () => {
+    it("normalizes GH numbers", () => {
+        expect(normalizePhoneForCountry("0501234567", "GH")).toBe("+233501234567");
+        expect(normalizePhoneForCountry("+233501234567", "GH")).toBe("+233501234567");
+        expect(normalizePhoneForCountry("  ", "GH")).toBeNull();
+    });
+    it("validates E.164", () => {
+        expect(isLikelyE164("+233501234567")).toBe(true);
+        expect(isLikelyE164("0501234567")).toBe(false);
+        expect(isLikelyE164("+1abc")).toBe(false);
+    });
+    it("resolves dial codes", () => {
+        expect(getDialCodeFromCountry("GH")).toBe("+233");
+        expect(getDialCodeFromCountry("US")).toBe("+1");
+        expect(getDialCodeFromCountry("XX")).toBeNull();
+    });
+});

package/dist/utils/sync-logger.js

@@ -29,10 +29,20 @@ class SyncLogger {
         this.warn = (namespace, message, data) => this.log("warn", namespace, message, data);
         this.error = (namespace, message, data) => this.log("error", namespace, message, data);
         try {
-            this.enabled = typeof __DEV__ !== "undefined" ? __DEV__ : process.env.NODE_ENV !== "production";
+            const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : false;
+            if (typeof isDev !== "undefined") {
+                this.enabled = isDev;
+                return;
+            }
+        }
+        catch { }
+        try {
+            // @ts-ignore
+            const nodeEnv = typeof process !== "undefined" ? process?.env?.NODE_ENV : undefined;
+            this.enabled = nodeEnv !== "production";
         }
         catch {
-            this.enabled = process.env.NODE_ENV !== "production";
+            this.enabled = true;
         }
     }
     setEnabled(enabled) {

package/dist/utils/uuid.test.d.ts

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

package/dist/utils/uuid.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { generateUUID, generateCommandId, generateEventId } from "./uuid";
+describe("uuid", () => {
+    it("generates valid v4 UUIDs", () => {
+        const id = generateUUID();
+        expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    });
+    it("generates prefixed ids", () => {
+        expect(generateCommandId()).toMatch(/^cmd_/);
+        expect(generateEventId()).toMatch(/^evt_/);
+        expect(generateCommandId()).not.toBe(generateEventId());
+    });
+});

package/dist/utils/validation.test.d.ts

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

package/dist/utils/validation.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { validateEmail, validatePhone, validatePassword, validatePromoCode } from "./validation";
+describe("validation", () => {
+    it("validates email", () => {
+        expect(validateEmail("a@b.com").valid).toBe(true);
+        expect(validateEmail("bad").valid).toBe(false);
+        expect(validateEmail("").errors).toContain("Email is required");
+    });
+    it("validates phone", () => {
+        expect(validatePhone("+233501234567").valid).toBe(true);
+        expect(validatePhone("123").valid).toBe(true); // minimal valid per regex
+        expect(validatePhone("").valid).toBe(false);
+    });
+    it("validates password strength", () => {
+        expect(validatePassword("StrongPass1").valid).toBe(true);
+        expect(validatePassword("short").valid).toBe(false);
+        expect(validatePassword("nouppercase1").valid).toBe(false);
+    });
+    it("validates promo code", () => {
+        expect(validatePromoCode("SAVE10").valid).toBe(true);
+        expect(validatePromoCode("ab").valid).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./dist/*.js": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    },
     "./dist/*": {
       "types": "./dist/*.d.ts",
       "import": "./dist/*.js"