@teincfood/core 0.9.4 → 0.9.7

package/dist/domain/orders/service.js

@@ -80,7 +80,7 @@ export async function createLocalOrder(businessId, input) {
     // Operating-hours gate (fail-closed, offline-first): matches backend
     // validate_business_open. Throws BUSINESS_CLOSED / HOURS_NOT_SYNCED before
     // anything is written, so a doomed order never enters SQLite/sync_jobs.
-    await assertBusinessOpenForCreate(businessId);
+    await assertBusinessOpenForCreate(businessId, new Date(), "pos");
     // DD lease required (backend lease, not local alloc) — keep leased DD even offline
     let dd = getDeviceNumber(businessId);
     if (!dd) {

package/dist/hooks/business-hours.hooks.d.ts

@@ -1,8 +1,8 @@
-import { type BusinessOpenState } from "../utils/business-hours";
+import { type BusinessOpenState, type OrderChannel } from "../utils/business-hours";
 import type { OperatingHoursEntry } from "../types/api/business.api";
 export declare const BUSINESS_HOURS_KEYS: {
     all: readonly ["business-hours"];
     open: (bid?: string) => readonly ["business-hours", "open", string | undefined];
 };
-export declare function useBusinessOpenNow(businessId?: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<BusinessOpenState, Error>;
+export declare function useBusinessOpenNow(businessId?: string, enabled?: boolean, channel?: OrderChannel): import("@tanstack/react-query").UseQueryResult<BusinessOpenState, Error>;
 export declare function useOperatingHours(businessId?: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<OperatingHoursEntry[], Error>;

package/dist/hooks/business-hours.hooks.js

@@ -11,13 +11,13 @@ export const BUSINESS_HOURS_KEYS = {
     all: ["business-hours"],
     open: (bid) => [...BUSINESS_HOURS_KEYS.all, "open", bid],
 };
-export function useBusinessOpenNow(businessId, enabled = true) {
+export function useBusinessOpenNow(businessId, enabled = true, channel = "online") {
     return useQuery({
-        queryKey: BUSINESS_HOURS_KEYS.open(businessId),
+        queryKey: [...BUSINESS_HOURS_KEYS.open(businessId), channel],
         queryFn: async () => {
             if (!businessId)
                 throw new Error("No business");
-            return isBusinessOpenNow(businessId);
+            return isBusinessOpenNow(businessId, new Date(), channel);
         },
         enabled: enabled && !!businessId,
         staleTime: 30 * 1000,

package/dist/index.d.ts

@@ -98,6 +98,7 @@ export * from "./reference/menu-record";
 export * from "./reference/menu-apply";
 export * from "./reference/capabilities";
 export * from "./reference/entitlements";
+export * from "./reference/entitlement-guard";
 export * from "./reference/entitlement-clock";
 export { hmacSha256Hex, sha256Hex } from "./reference/entitlement-crypto";
 export * from "./adapters/sqlite";

package/dist/index.js

@@ -100,6 +100,7 @@ export * from "./reference/menu-record";
 export * from "./reference/menu-apply";
 export * from "./reference/capabilities";
 export * from "./reference/entitlements";
+export * from "./reference/entitlement-guard";
 export * from "./reference/entitlement-clock";
 export { hmacSha256Hex, sha256Hex } from "./reference/entitlement-crypto";
 // ── Adapters (for host apps to supply) ──

package/dist/local-node/service.js

@@ -731,6 +731,17 @@ class LocalNodeServiceCore {
                 event = events[0] ?? null;
             }
             catch (error) {
+                // A 4xx is a backend rejection of THIS command (validation, auth,
+                // state) — not evidence the cloud is down. Rethrow without touching
+                // global reachability (mirrors sync engine); only network/5xx marks
+                // unreachable. Otherwise one rejected sync poisons every later
+                // resolveStrategy() into queueing and gates unrelated API ops.
+                const rejectionStatus = error?.status;
+                if (typeof rejectionStatus === "number" &&
+                    rejectionStatus >= 400 &&
+                    rejectionStatus < 500) {
+                    throw error;
+                }
                 syncLogger.warn("LocalNodeService", "Cloud forward failed, queueing", { error: String(error) });
                 try {
                     setConnectivityState({ isCloudReachable: "unreachable" });

package/dist/printer/receipt.d.ts

@@ -7,6 +7,7 @@
  * Keep this file in sync with backend when template changes.
  */
 import type { SellerOrder } from "../types/api/seller.api";
+export declare function escposText(s: string | null | undefined): string;
 export declare function calloutNumber(order: SellerOrder): string;
 export declare function generateEscpos(order: SellerOrder): string;
 export declare function generateHtmlAsync(order: SellerOrder, opts?: {

package/dist/printer/receipt.js

@@ -18,9 +18,43 @@ const ESC_BOLD_OFF = "\x1B\x45\x00";
 const GS_SIZE_NORMAL = "\x1D\x21\x00";
 const GS_SIZE_DOUBLE_W = "\x1D\x21\x11";
 const GS_SIZE_DOUBLE_WH = "\x1D\x21\x33";
+const GS_BAR_HEIGHT = "\x1D\x68\x3C";
+const GS_BAR_WIDTH = "\x1D\x77\x02";
 const LF = "\x0A";
 const ESC_FEED_3 = "\x1B\x64\x03";
 const GS_CUT_FULL = "\x1D\x56\x00";
+/**
+ * Thermal printers speak bytes, not Unicode. Control sequences are pushed
+ * raw, but every human-readable text segment must pass through here first:
+ * known symbols map to ASCII, anything else non-ASCII becomes "?".
+ * Without this, ₵/═/─/accents print as gibberish (UTF-8 bytes read as CP437).
+ */
+const ESCPOS_REPLACEMENTS = [
+    [/[₵]/g, "GHc"],
+    [/[€]/g, "EUR"],
+    [/[£]/g, "GBP"],
+    [/[—–]/g, "-"],
+    [/[•·]/g, "*"],
+    [/[═╬]/g, "="],
+    [/[─│]/g, "-"],
+    [/[“”]/g, '"'],
+    [/[‘’`]/g, "'"],
+    [/[…]/g, "..."],
+    [/[×]/g, "x"],
+    [/[°]/g, "deg"],
+    [/ /g, " "],
+];
+export function escposText(s) {
+    if (s == null)
+        return "";
+    let out = String(s);
+    for (const [re, sub] of ESCPOS_REPLACEMENTS)
+        out = out.replace(re, sub);
+    // Strip any remaining non-ASCII (accents, emoji, CJK) — the printer cannot
+    // render them and would print garbage bytes.
+    out = out.replace(/[^\x20-\x7E\n]/g, "?");
+    return out;
+}
 function padR(text, width) {
     if (text.length >= width)
         return text.slice(0, width);
@@ -60,14 +94,19 @@ function formatDatetime(iso) {
     }
 }
 export function calloutNumber(order) {
+    // The backend assigns a real callout_number — always prefer it.
+    const direct = order.callout_number;
+    if (typeof direct === "number" && Number.isFinite(direct))
+        return String(Math.abs(direct));
     const num = order.order_number || "";
     if (!num)
         return "----";
-    const last4 = num.slice(-4);
-    const n = parseInt(last4, 10);
-    if (Number.isNaN(n))
-        return last4;
-    return String(n);
+    // Strip non-digits first: local DD-RRR-CCC numbers end in "-CCC" and
+    // parseInt("-005") would give -5 (the old "-5" bug).
+    const digits = num.slice(-4).replace(/\D/g, "");
+    if (!digits)
+        return num.slice(-4);
+    return String(parseInt(digits, 10));
 }
 function itemName(item) {
     return item.menu_item?.name || "(deleted item)";
@@ -115,8 +154,19 @@ function businessAddress(business) {
         return null;
     if (b.location?.address)
         return b.location.address;
-    if (b.address)
+    if (typeof b.address === "string")
         return b.address;
+    // Desktop snapshots carry a structured address object — flatten it
+    // (printing the object itself would render "[object Object]").
+    if (b.address && typeof b.address === "object") {
+        if (b.address.fullAddress)
+            return b.address.fullAddress;
+        if (b.address.full_address)
+            return b.address.full_address;
+        const parts = [b.address.street, b.address.city].filter(Boolean);
+        if (parts.length)
+            return parts.join(", ");
+    }
     return null;
 }
 function businessLogoUrl(order) {
@@ -165,39 +215,47 @@ export function generateEscpos(order) {
     const parts = [];
     const push = (s) => { if (s != null)
         parts.push(s); };
+    // Sanitized text push: every human-readable segment goes through escposText
+    // (control codes and barcode data use raw push).
+    const pushT = (s) => { if (s != null)
+        parts.push(escposText(s)); };
     // Header — matches receipt.ex to_escpos/1
+    // NOTE: no logo in ESC/POS text mode — a logo URL cannot be rendered without
+    // a raster pipeline (GS v 0). HTML receipts embed the logo instead.
     push(ESC_INIT);
     push(ESC_ALIGN_CENTER);
     push(GS_SIZE_DOUBLE_WH);
-    push(business?.name || "Teinc Food");
+    pushT(business?.name || "Teinc Food");
     push(LF);
     push(GS_SIZE_NORMAL);
     const addr = businessAddress(business);
     if (addr)
-        push(addr + LF);
+        pushT(addr + LF);
     const bPhone = business?.phone;
     if (bPhone)
-        push(`Tel: ${bPhone}${LF}`);
+        pushT(`Tel: ${bPhone}${LF}`);
     push(GS_SIZE_NORMAL);
-    push(doubleLineEscpos());
+    pushT(doubleLineEscpos());
     // Order info
     push(ESC_ALIGN_LEFT);
-    push(`Order: ${order.order_number}${LF}`);
+    pushT(`Order: ${order.order_number}${LF}`);
     // callout_box_escpos
     push(ESC_ALIGN_CENTER);
     push(GS_SIZE_DOUBLE_W);
-    push(`Callout: ${calloutNumber(order)}${LF}`);
+    pushT(`Callout: ${calloutNumber(order)}${LF}`);
     push(GS_SIZE_NORMAL);
     push(LF);
     push(ESC_ALIGN_LEFT);
-    push(`Date: ${formatDatetime(order.inserted_at)}${LF}`);
-    push(`Type: ${orderTypeEscpos(order)}${LF}`);
+    pushT(`Date: ${formatDatetime(order.inserted_at)}${LF}`);
+    pushT(`Type: ${orderTypeEscpos(order)}${LF}`);
     const custLine = customerLineEscpos(order);
     if (custLine)
-        push(custLine);
+        pushT(custLine);
     push(LF);
-    // Barcode — CODE128 GS k 73
+    // Barcode — CODE128 GS k 73, sized down (default height is huge).
     push(ESC_ALIGN_CENTER);
+    push(GS_BAR_HEIGHT);
+    push(GS_BAR_WIDTH);
     const data = order.order_number || "";
     push(String.fromCharCode(0x1d, 0x6b, 0x49, data.length) + data);
     push(LF);
@@ -205,44 +263,44 @@ export function generateEscpos(order) {
     push(ESC_ALIGN_LEFT);
     push(`${padR("Item", 16)} Qty   Price`);
     push(LF);
-    push(singleLineEscpos());
+    pushT(singleLineEscpos());
     push(LF);
     for (const item of items) {
         const qty = item.quantity || 1;
         const price = formatMoney((item.unit_price ?? 0) * qty, order);
-        push(`  ${padR(itemName(item), 16)} ${padR(String(qty), 4)} ${padR(price, 9)}${LF}`);
+        pushT(`  ${padR(itemName(item), 16)} ${padR(String(qty), 4)} ${padR(price, 9)}${LF}`);
         const addons = item.order_item_addons ?? item.addons ?? [];
         for (const addon of addons) {
             const aName = addonName(addon);
             const aPriceMinor = addon.price_minor ?? addon.price ?? 0;
             const addonPrice = formatMoney(aPriceMinor, order);
-            push(`    + ${padR(aName, 12)}      ${padR(addonPrice, 9)}${LF}`);
+            pushT(`    + ${padR(aName, 12)}      ${padR(addonPrice, 9)}${LF}`);
         }
     }
-    push(singleLineEscpos());
+    pushT(singleLineEscpos());
     push(LF);
     // Subtotal section — mirrors subtotal_section_escpos/2
-    push(`${padR("Subtotal:", 20)} ${formatMoney(order.subtotal_minor, order)}${LF}`);
+    pushT(`${padR("Subtotal:", 20)} ${formatMoney(order.subtotal_minor, order)}${LF}`);
     if (order.delivery_fee_minor && order.delivery_fee_minor > 0) {
-        push(`${padR("Delivery Fee:", 20)} ${formatMoney(order.delivery_fee_minor, order)}${LF}`);
+        pushT(`${padR("Delivery Fee:", 20)} ${formatMoney(order.delivery_fee_minor, order)}${LF}`);
     }
     for (const tax of taxLines) {
         const rateStr = tax.rate_basis_points ? `(${Math.floor(tax.rate_basis_points / 100)}%)` : "";
         const label = `${tax.name || ""} ${rateStr}`.trim().slice(0, 19);
-        push(`${padR(label, 20)} ${formatMoney(tax.tax_amount_minor, order)}${LF}`);
+        pushT(`${padR(label, 20)} ${formatMoney(tax.tax_amount_minor, order)}${LF}`);
     }
     if (order.discount_minor && order.discount_minor > 0) {
-        push(`${padR("Discount:", 20)} -${formatMoney(order.discount_minor, order)}${LF}`);
+        pushT(`${padR("Discount:", 20)} -${formatMoney(order.discount_minor, order)}${LF}`);
     }
     push(ESC_BOLD_ON);
-    push(`${padR("TOTAL:", 20)} ${formatMoney(order.total_minor, order)}${LF}`);
+    pushT(`${padR("TOTAL:", 20)} ${formatMoney(order.total_minor, order)}${LF}`);
     push(ESC_BOLD_OFF);
     push(LF);
     push(ESC_ALIGN_CENTER);
-    push(paymentLineEscpos(order));
+    pushT(paymentLineEscpos(order));
     push(LF);
     // Footer
-    push(doubleLineEscpos());
+    pushT(doubleLineEscpos());
     push("Thank you for your order!" + LF);
     push("Come back soon!" + LF);
     push(ESC_FEED_3);

package/dist/reference/entitlement-guard.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Offline entitlement auto-guard — evaluates the cached signed
+ * `subscription:entitlements` envelope and enforces gated commands locally,
+ * before any transport is attempted. The backend remains the final authority
+ * (HTTP 402 SUBSCRIPTION_REQUIRED); this guard gives immediate feedback and
+ * keeps disallowed work out of the outbox.
+ *
+ * Fail-closed: missing envelope, missing secret, bad signature, expired, or
+ * stale (> max_offline_days) => gated commands throw SUBSCRIPTION_REQUIRED.
+ * The host app provisions the HMAC secret at boot via setEntitlementSecret
+ * and refreshes the envelope via reference sync; useEntitlements surfaces
+ * mustReconnect/paywall state for UI gates.
+ */
+import { type EntitlementEvaluation } from "./entitlements";
+/** Provisioned once at app boot from the host app's env. */
+export declare function setEntitlementSecret(secret: string | null): void;
+export declare function getEntitlementSecret(): string | null;
+export interface BusinessEntitlementState {
+    evaluation: EntitlementEvaluation;
+    features: Record<string, unknown> | null;
+}
+/** Evaluate the cached signed envelope for a business (no network). */
+export declare function evaluateBusinessEntitlements(businessId: string): Promise<BusinessEntitlementState>;
+export declare function isEntitlementGated(commandType: string): boolean;
+/**
+ * Throw SUBSCRIPTION_REQUIRED unless the cached entitlement proof covers
+ * this command. No-ops for non-gated commands — and when no envelope was
+ * ever cached (fresh terminal that never synced): the backend remains the
+ * authority there. Once proof exists, invalid/expired/stale proof denies.
+ */
+export declare function assertEntitledForCommand(businessId: string, commandType: string): Promise<void>;

package/dist/reference/entitlement-guard.js

@@ -0,0 +1,83 @@
+/**
+ * Offline entitlement auto-guard — evaluates the cached signed
+ * `subscription:entitlements` envelope and enforces gated commands locally,
+ * before any transport is attempted. The backend remains the final authority
+ * (HTTP 402 SUBSCRIPTION_REQUIRED); this guard gives immediate feedback and
+ * keeps disallowed work out of the outbox.
+ *
+ * Fail-closed: missing envelope, missing secret, bad signature, expired, or
+ * stale (> max_offline_days) => gated commands throw SUBSCRIPTION_REQUIRED.
+ * The host app provisions the HMAC secret at boot via setEntitlementSecret
+ * and refreshes the envelope via reference sync; useEntitlements surfaces
+ * mustReconnect/paywall state for UI gates.
+ */
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData } from "../reference/operations";
+import { evaluateEntitlements, getEntitledFeature, } from "./entitlements";
+import { assertEntitledFor } from "../sync/online-gates";
+let entitlementSecret = null;
+/** Provisioned once at app boot from the host app's env. */
+export function setEntitlementSecret(secret) {
+    entitlementSecret = secret;
+}
+export function getEntitlementSecret() {
+    return entitlementSecret;
+}
+/** Evaluate the cached signed envelope for a business (no network). */
+export async function evaluateBusinessEntitlements(businessId) {
+    const db = await openSyncDatabase();
+    const rec = await getReferenceData(db, businessId, "subscription:entitlements");
+    const payload = (rec?.payload ?? null);
+    const evaluation = await evaluateEntitlements({
+        businessId,
+        envelope: payload?.envelope,
+        features: payload?.data,
+        secret: entitlementSecret ?? "",
+    });
+    return { evaluation, features: payload?.data ?? null };
+}
+/**
+ * Per-command feature keys. Commands without an entry require overall
+ * `entitled` only (counts/quotas stay backend-enforced). delivery:assign is
+ * intentionally overall-only: merchants assigning their own riders are not
+ * subject to the fleet feature (backend scopes fleet.dispatch to
+ * delivery_provider businesses the same way).
+ */
+const FEATURE_BY_COMMAND = {
+    "promo:create": "seller.promo",
+};
+/** Real engine command types subject to the entitlement guard. */
+const GATED_COMMANDS = new Set([
+    "order:create",
+    "menu:create_item",
+    "menu:update_item",
+    "menu:delete_item",
+    "menu:create_category",
+    "promo:create",
+    "member:invite",
+    "member:manage",
+    "terminal:link",
+    "delivery:assign",
+]);
+export function isEntitlementGated(commandType) {
+    return GATED_COMMANDS.has(commandType);
+}
+/**
+ * Throw SUBSCRIPTION_REQUIRED unless the cached entitlement proof covers
+ * this command. No-ops for non-gated commands — and when no envelope was
+ * ever cached (fresh terminal that never synced): the backend remains the
+ * authority there. Once proof exists, invalid/expired/stale proof denies.
+ */
+export async function assertEntitledForCommand(businessId, commandType) {
+    if (!isEntitlementGated(commandType))
+        return;
+    const db = await openSyncDatabase();
+    const rec = await getReferenceData(db, businessId, "subscription:entitlements");
+    if (!rec?.payload)
+        return;
+    const { evaluation, features } = await evaluateBusinessEntitlements(businessId);
+    const feature = FEATURE_BY_COMMAND[commandType];
+    const entitled = evaluation.entitled &&
+        (!feature || getEntitledFeature(evaluation, features, feature));
+    assertEntitledFor(commandType, entitled, evaluation.reason);
+}

package/dist/reference/menu-record.d.ts

@@ -22,7 +22,7 @@ export interface MenuItemRecordInput {
     variants?: Array<{
         id?: string;
         name: string;
-        price_adjustment?: number;
+        price?: number;
     }>;
     extras?: Array<{
         id?: string;
@@ -51,8 +51,7 @@ export interface MenuItemEnvelopeInput extends MenuItemRecordInput {
 }
 /**
  * Build the { wire, cacheRecord } pair for a menu item write. Callers pass
- * backend adjustment-shaped variants; absolute form prices are converted by
- * the caller (form layer owns both fields).
+ * absolute variant prices (backend model) — the form layer owns the field.
  *
  * Variant/extra ids are preserved when they are backend UUIDs. The backend
  * update path deletes existing rows absent from the incoming list, so

package/dist/reference/menu-record.js

@@ -29,8 +29,8 @@ export function buildMenuItemRecord(input) {
         variants: (input.variants ?? []).map((v) => ({
             id: v.id ?? generateUUID(),
             name: v.name,
-            // Matches backend serializer: variant price = base + adjustment.
-            price: { amountMinor: input.priceMinor + (v.price_adjustment ?? 0), currencyCode },
+            // Absolute variant price (backend model) — no size defaults to base.
+            price: { amountMinor: v.price ?? input.priceMinor, currencyCode },
         })),
         extras: (input.extras ?? []).map((e) => ({
             id: e.id ?? generateUUID(),
@@ -123,8 +123,7 @@ function wireId(id) {
 }
 /**
  * Build the { wire, cacheRecord } pair for a menu item write. Callers pass
- * backend adjustment-shaped variants; absolute form prices are converted by
- * the caller (form layer owns both fields).
+ * absolute variant prices (backend model) — the form layer owns the field.
  *
  * Variant/extra ids are preserved when they are backend UUIDs. The backend
  * update path deletes existing rows absent from the incoming list, so
@@ -145,8 +144,8 @@ export function buildMenuItemEnvelope(input) {
         variants: (input.variants ?? []).map((v) => {
             const vid = wireId(v.id);
             return vid
-                ? { id: vid, name: v.name, price_adjustment: v.price_adjustment ?? 0 }
-                : { name: v.name, price_adjustment: v.price_adjustment ?? 0 };
+                ? { id: vid, name: v.name, price: v.price ?? input.priceMinor }
+                : { name: v.name, price: v.price ?? input.priceMinor };
         }),
         extras: (input.extras ?? []).map((e) => {
             const eid = wireId(e.id);

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

@@ -210,7 +210,7 @@ class CommandQueueService {
         // types (transitions, payments, delivery) are unaffected so in-progress
         // orders can still be completed while closed.
         if (command.command_type === "order:create") {
-            await assertBusinessOpenForCreate(command.business_id);
+            await assertBusinessOpenForCreate(command.business_id, new Date(), "pos");
         }
         const db = getSyncDatabase();
         const preparedCommand = injectLocalOrderNumber(command);

package/dist/sync/engine.js

@@ -24,6 +24,7 @@ import { getReferenceData } from "../reference/operations";
 import { openSyncDatabase } from "../db/connection";
 import { canBusinessSync } from "./sync-guard";
 import { TRANSITION_ERROR_CODES, TransitionError } from "./transition-errors";
+import { assertEntitledForCommand } from "../reference/entitlement-guard";
 function withTimeout(promise, ms) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -79,6 +80,22 @@ export class SyncEngine {
                 // otherwise fail open
             }
         }
+        // Entitlement guard (fail-closed, offline-first): subscription-gated
+        // commands need cached proof before routing. Backend 402 backstops.
+        try {
+            await assertEntitledForCommand(command.business_id, command.command_type);
+        }
+        catch (e) {
+            if (e instanceof TransitionError &&
+                e.code === TRANSITION_ERROR_CODES.SUBSCRIPTION_REQUIRED) {
+                throw e;
+            }
+            // Guard infra failure (no DB yet, corrupt cache) must not brick the
+            // terminal — backend remains the authority. Log and continue.
+            syncLogger.warn("SyncEngine", "entitlement guard skipped", {
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
         let strategy = this.resolveStrategy(command);
         const { isCloudReachable, isOnline } = getConnectivityState();
         syncLogger.info("SyncEngine", "Command strategy resolved", {

package/dist/sync/online-gates.js

@@ -69,7 +69,7 @@ export function assertOnlineFor(commandType, payload) {
  */
 export function assertEntitledFor(commandType, entitled, evaluationReason) {
     const gated = new Set([
-        "order:create_online",
+        "order:create",
         "menu:create_item",
         "menu:update_item",
         "menu:delete_item",
@@ -78,7 +78,7 @@ export function assertEntitledFor(commandType, entitled, evaluationReason) {
         "member:invite",
         "member:manage",
         "terminal:link",
-        "fleet:dispatch_create",
+        "delivery:assign",
     ]);
     if (!gated.has(commandType))
         return;

package/dist/types/api/menu.api.d.ts

@@ -52,7 +52,8 @@ export interface MenuItemListResponse {
 export interface MenuItemVariant {
     id: string;
     name: string;
-    price_adjustment: number;
+    /** Absolute variant price in minor units (replaces the base price). */
+    price: number;
 }
 export interface MenuItemAddon {
     id: string;
@@ -80,7 +81,8 @@ export interface CatalogItemRequest {
     variants: {
         id?: string;
         name: string;
-        price_adjustment: number;
+        /** Absolute variant price in minor units (replaces the base price). */
+        price: number;
     }[];
     extras: {
         id?: string;

package/dist/utils/business-hours.d.ts

@@ -1,8 +1,10 @@
 /**
  * Business open/closed evaluation — single source for the lib.
  *
- * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` exactly:
- *   - `manually_closed` → closed
+ * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` for the `online`
+ * channel and `open_for_pos?/1` for the `pos` channel:
+ *   - `manually_closed` → closed for online; IGNORED for pos (temporary
+ *     online shutdown must not stop the POS terminal)
  *   - else UTC clock: day = Elixir `Date.day_of_week - 1` (Monday=0 … Sunday=6),
  *     a row matches when `day_of_week` equals today, `is_closed` is false and
  *     `open_time <= now < close_time` (open inclusive, close exclusive).
@@ -13,6 +15,8 @@
  * fixed here): overnight ranges (close <= open) never match.
  */
 export type BusinessClosedReason = "manually_closed" | "outside_hours" | "no_hours_configured";
+/** Order channel: online buyer orders vs in-store POS orders. */
+export type OrderChannel = "online" | "pos";
 export interface BusinessOpenState {
     open: boolean;
     reason?: BusinessClosedReason;
@@ -27,11 +31,11 @@ export declare class BusinessHoursError extends Error {
     reason?: BusinessClosedReason;
     constructor(code: "BUSINESS_CLOSED" | "HOURS_NOT_SYNCED", message: string, reason?: BusinessClosedReason);
 }
-export declare function isBusinessOpenNow(businessId: string, now?: Date): Promise<BusinessOpenState>;
+export declare function isBusinessOpenNow(businessId: string, now?: Date, channel?: OrderChannel): Promise<BusinessOpenState>;
 /**
  * Guard for order creation — fail-closed. Throws `BusinessHoursError` with
  * code `HOURS_NOT_SYNCED` when no hours are cached (configure in Settings,
  * works offline) or `BUSINESS_CLOSED` when the business is closed.
  * Backend remains the final gate for clock-skew edge cases.
  */
-export declare function assertBusinessOpenForCreate(businessId: string, now?: Date): Promise<BusinessOpenState>;
+export declare function assertBusinessOpenForCreate(businessId: string, now?: Date, channel?: OrderChannel): Promise<BusinessOpenState>;

package/dist/utils/business-hours.js

@@ -1,8 +1,10 @@
 /**
  * Business open/closed evaluation — single source for the lib.
  *
- * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` exactly:
- *   - `manually_closed` → closed
+ * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` for the `online`
+ * channel and `open_for_pos?/1` for the `pos` channel:
+ *   - `manually_closed` → closed for online; IGNORED for pos (temporary
+ *     online shutdown must not stop the POS terminal)
  *   - else UTC clock: day = Elixir `Date.day_of_week - 1` (Monday=0 … Sunday=6),
  *     a row matches when `day_of_week` equals today, `is_closed` is false and
  *     `open_time <= now < close_time` (open inclusive, close exclusive).
@@ -41,7 +43,7 @@ function normalizeEntries(payload) {
         return data;
     return [];
 }
-export async function isBusinessOpenNow(businessId, now = new Date()) {
+export async function isBusinessOpenNow(businessId, now = new Date(), channel = "online") {
     const evaluatedAt = new Date().toISOString();
     // Backend: Date.day_of_week (Mon=1..Sun=7) minus 1 → Mon=0..Sun=6 (UTC).
     const dayOfWeek = (now.getUTCDay() + 6) % 7;
@@ -56,7 +58,7 @@ export async function isBusinessOpenNow(businessId, now = new Date()) {
     const profileData = profile && typeof profile === "object" && "data" in profile && profile.data !== undefined
         ? profile.data
         : (profile ?? {});
-    if (profileData.manually_closed === true) {
+    if (profileData.manually_closed === true && channel !== "pos") {
         return { open: false, reason: "manually_closed", dayOfWeek, timeUtc, evaluatedAt };
     }
     const entries = normalizeEntries(hoursRec?.payload);
@@ -82,8 +84,8 @@ export async function isBusinessOpenNow(businessId, now = new Date()) {
  * works offline) or `BUSINESS_CLOSED` when the business is closed.
  * Backend remains the final gate for clock-skew edge cases.
  */
-export async function assertBusinessOpenForCreate(businessId, now = new Date()) {
-    const state = await isBusinessOpenNow(businessId, now);
+export async function assertBusinessOpenForCreate(businessId, now = new Date(), channel = "online") {
+    const state = await isBusinessOpenNow(businessId, now, channel);
     if (state.reason === "no_hours_configured") {
         throw new BusinessHoursError("HOURS_NOT_SYNCED", "Operating hours are not available offline — configure them in Settings (works offline) or sync once before taking orders", state.reason);
     }

package/dist/utils/order-transitions.d.ts

@@ -12,6 +12,19 @@ export declare const ORDER_STATUSES: readonly ["pending", "awaiting_payment", "a
 export type OrderStatus = (typeof ORDER_STATUSES)[number];
 export declare const CANCELLABLE_STATUSES: readonly ["pending", "awaiting_payment", "accepted", "preparing", "ready"];
 export declare const PIPELINE: readonly ["pending", "accepted", "preparing", "ready", "delivered"];
+export type StageState = "done" | "current" | "upcoming";
+export interface PipelineStage {
+    status: string;
+    state: StageState;
+}
+/**
+ * Derives hierarchical stage states for `current` over `steps`
+ * (defaults to PIPELINE). Stages before the current index are `done`,
+ * the current index is `current`, later stages are `upcoming`.
+ * Unknown statuses (e.g. cancelled, awaiting_payment) yield all `upcoming`
+ * so callers can apply their own mapping first.
+ */
+export declare function stageStatuses(current: string, steps?: readonly string[]): PipelineStage[];
 export type OrderAction = "accept" | "reject" | "start_preparing" | "mark_ready" | "complete_pickup" | "cancel" | "assign_rider" | "confirm_handover" | "confirm_cash" | "pay";
 export declare function isUnpaid(order: SellerOrder): boolean;
 export declare function isCancellable(status: string): boolean;

package/dist/utils/order-transitions.js

@@ -19,6 +19,20 @@ export const CANCELLABLE_STATUSES = [
     "ready",
 ];
 export const PIPELINE = ["pending", "accepted", "preparing", "ready", "delivered"];
+/**
+ * Derives hierarchical stage states for `current` over `steps`
+ * (defaults to PIPELINE). Stages before the current index are `done`,
+ * the current index is `current`, later stages are `upcoming`.
+ * Unknown statuses (e.g. cancelled, awaiting_payment) yield all `upcoming`
+ * so callers can apply their own mapping first.
+ */
+export function stageStatuses(current, steps = PIPELINE) {
+    const idx = steps.indexOf(current);
+    return steps.map((status, i) => ({
+        status,
+        state: idx < 0 || i > idx ? "upcoming" : i === idx ? "current" : "done",
+    }));
+}
 // ── Helpers ───────────────────────────────────────────────────────────────
 export function isUnpaid(order) {
     const o = order;

package/dist/validation/offline.d.ts

@@ -19,6 +19,8 @@ export declare function validateMenuItemInput(input: {
     categoryId?: unknown;
     variants?: Array<{
         name?: unknown;
+        price?: unknown;
+        price_minor?: unknown;
     }>;
     extras?: Array<{
         name?: unknown;

package/dist/validation/offline.js

@@ -41,6 +41,12 @@ export function validateMenuItemInput(input) {
     for (const v of input.variants ?? []) {
         if (!v || typeof v.name !== "string" || !v.name.trim())
             fail("variants", "Variant name is required", details);
+        // Absolute variant price mirrors backend (must be 0 or more when given).
+        // Accepts both envelope shape (price) and form shape (price_minor).
+        const vp = v.price ?? v.price_minor;
+        if (vp !== undefined && (typeof vp !== "number" || !Number.isFinite(vp) || vp < 0)) {
+            fail("variants", "Variant price must be 0 or more", details);
+        }
     }
     for (const e of input.extras ?? []) {
         if (!e || typeof e.name !== "string" || !e.name.trim())

package/package.json

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