@teincfood/core 0.1.3 → 0.1.5

package/dist/adapters/services.d.ts

@@ -36,12 +36,17 @@ 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>;
     fetchBusinessTaxRules: (_businessId: string) => Promise<unknown>;
     fetchBusinessById: (_businessId: string) => Promise<unknown>;
     fetchOperatingHours: (_businessId: string) => Promise<unknown>;
+    fetchMyBusinessMembership: (_businessId: string) => Promise<unknown>;
 };
 export declare const rolesService: {
     fetchBusinessRoles: () => 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) => {
@@ -69,6 +81,9 @@ export const businessService = {
     fetchOperatingHours: async (_businessId) => {
         notImpl("businessService.fetchOperatingHours");
     },
+    fetchMyBusinessMembership: async (_businessId) => {
+        notImpl("businessService.fetchMyBusinessMembership");
+    },
 };
 export const rolesService = {
     fetchBusinessRoles: async () => {

package/dist/index.d.ts

@@ -6,25 +6,55 @@
  */
 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 "./reference/capabilities";
 export * from "./adapters/sqlite";
 export * from "./adapters/kv";
 export * from "./adapters/connectivity";
@@ -41,6 +71,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,30 +7,55 @@
 // ── 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";
+export * from "./reference/capabilities";
 // ── Adapters (for host apps to supply) ──
 export * from "./adapters/sqlite";
 export * from "./adapters/kv";
@@ -45,19 +70,52 @@ 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/reference/capabilities.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Capabilities reference — offline-first.
+ *
+ * Standardises business-membership capabilities for both mobile and desktop.
+ * The backend `GET /businesses/:id/my-membership` is the source of truth;
+ * the result is mirrored to `reference_data` key `capabilities` so drawer/nav
+ * filtering works offline and survives restarts.
+ *
+ * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
+ */
+/**
+ * Standard hook for both apps — businessId comes from the host's active business store.
+ * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ */
+export declare function useBusinessCapabilities(businessId?: string | null): import("@tanstack/react-query").UseQueryResult<{
+    role: string;
+    source: string;
+    capabilities: string[];
+    status: string;
+}, Error>;
+export declare function useHasCapabilityFor(businessId: string | undefined, capability: string): boolean;

package/dist/reference/capabilities.js

@@ -0,0 +1,81 @@
+/**
+ * Capabilities reference — offline-first.
+ *
+ * Standardises business-membership capabilities for both mobile and desktop.
+ * The backend `GET /businesses/:id/my-membership` is the source of truth;
+ * the result is mirrored to `reference_data` key `capabilities` so drawer/nav
+ * filtering works offline and survives restarts.
+ *
+ * Host apps wire `businessService.fetchMyBusinessMembership` via adapters/services.
+ */
+import { useEffect, useState } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData, setReferenceData } from "./operations";
+import { businessService } from "../adapters/services";
+const MEMBERSHIP_KEYS = {
+    all: ["my-membership"],
+    byBusiness: (id) => [...MEMBERSHIP_KEYS.all, id],
+};
+function useCapabilitiesPlaceholder(businessId) {
+    const [cached, setCached] = useState(null);
+    useEffect(() => {
+        if (!businessId) {
+            setCached(null);
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const db = await openSyncDatabase();
+                const rec = await getReferenceData(db, businessId, "capabilities");
+                if (!cancelled && rec?.payload)
+                    setCached(rec.payload);
+            }
+            catch { }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [businessId]);
+    return cached;
+}
+/**
+ * Standard hook for both apps — businessId comes from the host's active business store.
+ * Returns the same shape as the previous app-level useMyBusinessCapabilities.
+ */
+export function useBusinessCapabilities(businessId) {
+    const queryClient = useQueryClient();
+    void queryClient;
+    const cached = useCapabilitiesPlaceholder(businessId ?? null);
+    return useQuery({
+        queryKey: MEMBERSHIP_KEYS.byBusiness(businessId ?? ""),
+        queryFn: async () => {
+            const res = (await businessService.fetchMyBusinessMembership(businessId));
+            try {
+                const db = await openSyncDatabase();
+                await setReferenceData(db, businessId, {
+                    key: "capabilities",
+                    version: `membership-${Date.now()}`,
+                    payload: res,
+                    downloadedAt: new Date().toISOString(),
+                });
+            }
+            catch { }
+            return res;
+        },
+        enabled: !!businessId,
+        staleTime: Infinity,
+        placeholderData: cached ?? undefined,
+        select: (data) => ({
+            role: data.data.role,
+            source: data.data.source,
+            capabilities: data.data.capabilities,
+            status: data.data.status,
+        }),
+    });
+}
+export function useHasCapabilityFor(businessId, capability) {
+    const { data } = useBusinessCapabilities(businessId);
+    return data?.capabilities.includes(capability) ?? false;
+}

package/dist/reference/service.js

@@ -23,6 +23,7 @@ const DEFAULT_SYNC_KEYS = [
     "business:profile",
     "operating-hours",
     "subscription:entitlements",
+    "capabilities",
 ];
 class ReferenceSyncService {
     constructor() {
@@ -204,6 +205,13 @@ class ReferenceSyncService {
                     version: this.hashPayload(response),
                 };
             }
+            case "capabilities": {
+                const response = await businessService.fetchMyBusinessMembership(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
             default:
                 throw new Error(`No fallback fetch available for ${key}`);
         }

package/dist/reference/types.d.ts

@@ -8,7 +8,7 @@
  * It is synchronized separately from transactional data through the
  * ReferenceSyncService.
  */
-export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "subscription:entitlements";
+export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "subscription:entitlements" | "capabilities";
 export interface ReferenceDataRecord<T = unknown> {
     key: ReferenceDataKey;
     version: string;

package/dist/sync/command-queue.service.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Command, DomainEvent, PersistedCommand } from "./types";
 import type { SyncEngine } from "./engine";
+export declare function getQueuedStatus(commandType: string): string | null;
 declare class CommandQueueService {
     private replaying;
     private syncEngine;

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

@@ -14,8 +14,34 @@ import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
 import { generateLocalOrderNumber, generateLocalCalloutNumber, } from "./order-number";
 const MAX_RETRIES = 5;
+const QUEUED_STATUS_BY_COMMAND = {
+    "order:accept": "accepted",
+    "order:reject": "cancelled",
+    "order:start_preparing": "preparing",
+    "order:mark_ready": "ready",
+    "order:complete_pickup": "delivered",
+    "order:cancel": "cancelled",
+    "delivery:assign": "assigned",
+    "delivery:confirm_handover": "delivered",
+};
+export function getQueuedStatus(commandType) {
+    return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
+}
 function buildOptimisticEvent(command) {
     const payload = command.payload;
+    if (command.command_type === "order:create") {
+        return {
+            event_id: generateEventId(),
+            event_type: `${command.command_type.replace(":", ".")}_queued`,
+            event_version: "1.0",
+            entity_id: command.entity_id ?? command.command_id,
+            user_id: command.user_id,
+            device_id: command.device_id,
+            payload: buildOptimisticOrder(command, payload),
+            timestamp: new Date().toISOString(),
+        };
+    }
+    const queuedStatus = getQueuedStatus(command.command_type);
     return {
         event_id: generateEventId(),
         event_type: `${command.command_type.replace(":", ".")}_queued`,
@@ -23,13 +49,15 @@ function buildOptimisticEvent(command) {
         entity_id: command.entity_id ?? command.command_id,
         user_id: command.user_id,
         device_id: command.device_id,
-        payload: command.command_type === "order:create"
-            ? buildOptimisticOrder(command, payload)
-            : {
-                ...payload,
-                command_id: command.command_id,
-                status: "pending",
-            },
+        payload: {
+            ...payload,
+            command_id: command.command_id,
+            status: "pending",
+            // Used by offline read-model patching so the list reflects the queued transition.
+            to_status: queuedStatus,
+            order_id: command.entity_id,
+            delivery_id: command.entity_id,
+        },
         timestamp: new Date().toISOString(),
     };
 }
@@ -136,17 +164,17 @@ class CommandQueueService {
             order_number: event.payload.order_number ?? null,
             status: event.payload.status,
         });
-        // Persist the optimistic order so it survives app restarts and can be
-        // rehydrated (and shown) while still offline.
-        if (preparedCommand.command_type === "order:create") {
-            try {
-                await insertEvent(db, { event, origin: "local" });
-            }
-            catch (error) {
-                syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
-                    error: String(error),
-                });
-            }
+        // Persist optimistic events so they survive restarts and can be
+        // rehydrated offline. For order:create this is the full order; for
+        // transitions it carries to_status so the read model can reflect the
+        // queued status immediately.
+        try {
+            await insertEvent(db, { event, origin: "local" });
+        }
+        catch (error) {
+            syncLogger.error("CommandQueueService", "Failed to persist optimistic event", {
+                error: String(error),
+            });
         }
         return event;
     }
@@ -188,6 +216,24 @@ 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;
+            const isNonRetryable = apiErr?.name === "ApiError" &&
+                typeof apiErr.status === "number" &&
+                apiErr.status >= 400 &&
+                apiErr.status < 500;
+            if (isNonRetryable) {
+                await updateCommandStatus(db, command.command_id, "failed", `permanent:${message}`);
+                syncLogger.warn("CommandQueueService", "Queued command rejected by server (not retrying)", {
+                    command_id: command.command_id,
+                    command_type: command.command_type,
+                    status: apiErr.status,
+                    error: message,
+                });
+                // Do not throw — allow replay to continue to next command.
+                return;
+            }
             await updateCommandStatus(db, command.command_id, "failed", message);
             syncLogger.command(parsedCommand, "failed", { error: message });
             throw error;
@@ -218,8 +264,17 @@ class CommandQueueService {
                 try {
                     await this.processCommand(command);
                 }
-                catch {
-                    // Stop replay on first failure; retry will happen on next trigger.
+                catch (e) {
+                    const apiErr = e;
+                    const isNonRetryable = apiErr?.name === "ApiError" &&
+                        typeof apiErr.status === "number" &&
+                        apiErr.status >= 400 &&
+                        apiErr.status < 500;
+                    if (isNonRetryable) {
+                        // Already marked permanent in processCommand — continue to next.
+                        continue;
+                    }
+                    // Network/5xx — stop to preserve ordering; retry later.
                     break;
                 }
             }

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-snapshots.service.d.ts

@@ -22,6 +22,13 @@ declare class OrderSnapshotsService {
      * duplicates).
      */
     persistOrderEvent(event: DomainEvent, origin: "local" | "lan" | "cloud"): Promise<boolean>;
+    /**
+     * Patch the latest status for a queued transition (e.g. accept_queued)
+     * carrying to_status/order_id. Used so offline devices see the new status
+     * immediately and after restart via the durable snapshot.
+     */
+    applyQueuedStatusEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
+    private applyOrderStatusToReadModelInternal;
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.

package/dist/sync/order-snapshots.service.js

@@ -50,17 +50,29 @@ class OrderSnapshotsService {
         }
     }
     /**
-     * Patch the latest status of a known order inside every list snapshot for the
-     * business, so offline devices see live status changes without a refetch.
+     * Patch the latest status for a queued transition (e.g. accept_queued)
+     * carrying to_status/order_id. Used so offline devices see the new status
+     * immediately and after restart via the durable snapshot.
      */
-    async applyOrderStatusToReadModel(db, event) {
+    async applyQueuedStatusEvent(event, origin = "local") {
         const payload = event.payload;
-        const orderId = payload?.order_id;
-        const toStatus = payload?.to_status ??
-            payload?.status;
-        if (!orderId || !toStatus || event.event_type !== "order.status_changed") {
+        const toStatus = payload?.to_status;
+        const orderId = payload?.order_id ?? event.entity_id;
+        if (!toStatus || !orderId)
             return;
+        try {
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            await this.applyOrderStatusToReadModelInternal(db, orderId, toStatus, event);
+        }
+        catch (error) {
+            syncLogger.error("OrderSnapshots", "Failed to apply queued status", {
+                error: String(error),
+                event_type: event.event_type,
+            });
         }
+    }
+    async applyOrderStatusToReadModelInternal(db, orderId, toStatus, event) {
         try {
             const lists = await getEntitySnapshotsByType(db, "seller_orders");
             for (const list of lists) {
@@ -85,6 +97,20 @@ class OrderSnapshotsService {
             });
         }
     }
+    /**
+     * Patch the latest status of a known order inside every list snapshot for the
+     * business, so offline devices see live status changes without a refetch.
+     */
+    async applyOrderStatusToReadModel(db, event) {
+        const payload = event.payload;
+        const orderId = payload?.order_id;
+        const toStatus = payload?.to_status ??
+            payload?.status;
+        if (!orderId || !toStatus || event.event_type !== "order.status_changed") {
+            return;
+        }
+        await this.applyOrderStatusToReadModelInternal(db, orderId, toStatus, event);
+    }
     /**
      * Write through a fetched order list so it is available offline. Used by the
      * seller and POS order queries. `scope` distinguishes complementary lists

package/dist/sync/pending-orders.service.js

@@ -26,6 +26,16 @@ const ORDER_STATE_EVENT_TYPES = new Set([
     "delivery.status_changed",
     "delivery.assigned",
 ]);
+const QUEUED_STATUS_EVENT_TYPES = new Set([
+    "order.accept_queued",
+    "order.reject_queued",
+    "order.start_preparing_queued",
+    "order.mark_ready_queued",
+    "order.complete_pickup_queued",
+    "order.cancel_queued",
+    "delivery.assign_queued",
+    "delivery.confirm_handover_queued",
+]);
 let invalidator = null;
 /**
  * Register a callback used to invalidate TanStack Query caches when a pending
@@ -88,7 +98,8 @@ export async function hydratePendingOrders() {
  */
 export async function applyOrderStateChangeEvent(event, origin = "local") {
     try {
-        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type))
+        const isQueued = QUEUED_STATUS_EVENT_TYPES.has(event.event_type);
+        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued)
             return;
         syncLogger.debug("OrderState", "Order state changed", {
             origin,
@@ -97,6 +108,12 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         });
         // Persist the event into the durable journal and patch the offline read
         // model so every terminal keeps the same order states after a restart.
+        // Queued transitions carry to_status/order_id so they patch instantly offline.
+        if (isQueued) {
+            await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            invalidator?.();
+            return;
+        }
         await orderSnapshotsService.persistOrderEvent(event, origin);
         invalidator?.();
     }
@@ -118,6 +135,14 @@ export async function applyPendingOrderEvent(event, origin = "local") {
             await insertEvent(db, { event, origin });
             return;
         }
+        if (QUEUED_STATUS_EVENT_TYPES.has(event.event_type)) {
+            // Queued transitions: patch the read model so listing reflects new status offline.
+            await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            invalidator?.();
+            return;
+        }
         if (event.event_type === "order.created") {
             const payload = event.payload;
             const localOrderNumber = payload?.local_order_number;

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",