@teincfood/core 0.9.18 → 0.9.20

package/dist/db/migrations.js

@@ -408,4 +408,19 @@ export const MIGRATIONS = [
         `);
         },
     },
+    {
+        version: 11,
+        up: async (db) => {
+            // Terminal sync failure marker: set when a queued order:create or a
+            // transition dead-letters (e.g. the parent order was never created, or a
+            // transition 404s because the order does not exist server-side). The row
+            // is retained for audit instead of being silently dropped.
+            await db.execAsync(`
+          ALTER TABLE orders ADD COLUMN sync_failed_at TEXT;
+        `);
+            await db.execAsync(`
+          ALTER TABLE orders ADD COLUMN sync_error TEXT;
+        `);
+        },
+    },
 ];

package/dist/db/operations.d.ts

@@ -67,6 +67,8 @@ export interface OrderRow {
     updated_at: string | null;
     hlc: string | null;
     deleted_at: string | null;
+    sync_failed_at?: string | null;
+    sync_error?: string | null;
 }
 export declare function insertOrder(db: SQLiteDatabase, order: import("../types/api/seller.api").SellerOrder & {
     hlc?: string;
@@ -79,11 +81,18 @@ export declare function listOrders(db: SQLiteDatabase, businessId: string, filte
     order_type?: string;
     date_from?: string;
     date_to?: string;
+    is_paid?: string;
 }, page?: number, pageSize?: number): Promise<{
     data: import("../types/api/seller.api").SellerOrder[];
     total: number;
 }>;
 export declare function updateOrderStatus(db: SQLiteDatabase, businessId: string, orderId: string, toStatus: string, hlc?: string): Promise<void>;
+/**
+ * Flag an order whose queued work dead-lettered (parent create failed, or a
+ * transition 404'd because the server has no such order). The row is kept for
+ * audit rather than deleted; a later pull of the real order clears the flag.
+ */
+export declare function markOrderSyncFailed(db: SQLiteDatabase, businessId: string, orderId: string, message: string): Promise<void>;
 export declare function updateOrderPayment(db: SQLiteDatabase, businessId: string, orderId: string, patch: {
     is_paid: boolean;
     paid_at: string | null;

package/dist/db/operations.js

@@ -228,6 +228,8 @@ function orderRowToSellerOrder(row) {
         paid_at: row.payment ? JSON.parse(row.payment).paid_at ?? null : null,
         inserted_at: row.inserted_at,
         updated_at: row.updated_at ?? row.inserted_at,
+        sync_failed_at: row.sync_failed_at ?? null,
+        sync_error: row.sync_error ?? null,
     };
 }
 export async function insertOrder(db, order) {
@@ -235,7 +237,7 @@ export async function insertOrder(db, order) {
     const updatedAt = order.updated_at ?? order.inserted_at;
     await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(id) DO UPDATE SET business_id=excluded.business_id, order_number=excluded.order_number, callout_number=excluded.callout_number, status=excluded.status, order_type=excluded.order_type, is_pos=excluded.is_pos, items=excluded.items, subtotal_minor=excluded.subtotal_minor, total_minor=excluded.total_minor, tax_minor=excluded.tax_minor, tax_lines=excluded.tax_lines, payment=excluded.payment, customer_name=excluded.customer_name, customer_phone=excluded.customer_phone, pos_payment_method=excluded.pos_payment_method, delivery_id=excluded.delivery_id, business=excluded.business, user=excluded.user, updated_at=excluded.updated_at, hlc=excluded.hlc
+     ON CONFLICT(id) DO UPDATE SET business_id=excluded.business_id, order_number=excluded.order_number, callout_number=excluded.callout_number, status=excluded.status, order_type=excluded.order_type, is_pos=excluded.is_pos, items=excluded.items, subtotal_minor=excluded.subtotal_minor, total_minor=excluded.total_minor, tax_minor=excluded.tax_minor, tax_lines=excluded.tax_lines, payment=excluded.payment, customer_name=excluded.customer_name, customer_phone=excluded.customer_phone, pos_payment_method=excluded.pos_payment_method, delivery_id=excluded.delivery_id, business=excluded.business, user=excluded.user, updated_at=excluded.updated_at, hlc=excluded.hlc, sync_failed_at=NULL, sync_error=NULL
      WHERE excluded.hlc >= orders.hlc OR orders.hlc IS NULL;`, order.id, order.business_id, order.order_number, order.callout_number, order.status, order.order_type, order.is_pos ? 1 : 0, JSON.stringify(order.items), order.subtotal_minor, order.total_minor, order.tax_minor, JSON.stringify(order.tax_lines), JSON.stringify(order.payment), order.customer_name, order.customer_phone, order.pos_payment_method, order.delivery_id, order.business ? JSON.stringify(order.business) : null, order.user ? JSON.stringify(order.user) : null, order.inserted_at, updatedAt, hlc);
     notifyDbChange(order.business_id, "orders");
 }
@@ -261,6 +263,12 @@ export async function listOrders(db, businessId, filters, page = 1, pageSize = 2
         where.push("order_type = ?");
         args.push(filters.order_type);
     }
+    if (filters?.is_paid === "paid") {
+        where.push("json_extract(payment, '$.is_paid') = 1");
+    }
+    else if (filters?.is_paid === "unpaid") {
+        where.push("(json_extract(payment, '$.is_paid') IS NULL OR json_extract(payment, '$.is_paid') = 0)");
+    }
     if (filters?.q) {
         where.push("(order_number LIKE ? OR customer_name LIKE ? OR customer_phone LIKE ?)");
         const q = `%${filters.q}%`;
@@ -286,6 +294,18 @@ export async function updateOrderStatus(db, businessId, orderId, toStatus, hlc)
     await db.runAsync(`UPDATE orders SET status = ?, hlc = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, toStatus, now, businessId, orderId, orderId);
     notifyDbChange(businessId, "orders");
 }
+/**
+ * Flag an order whose queued work dead-lettered (parent create failed, or a
+ * transition 404'd because the server has no such order). The row is kept for
+ * audit rather than deleted; a later pull of the real order clears the flag.
+ */
+export async function markOrderSyncFailed(db, businessId, orderId, message) {
+    try {
+        await db.runAsync(`UPDATE orders SET sync_failed_at = ?, sync_error = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, new Date().toISOString(), message, businessId, orderId, orderId);
+        notifyDbChange(businessId, "orders");
+    }
+    catch { }
+}
 export async function updateOrderPayment(db, businessId, orderId, patch) {
     const row = await getOrderById(db, businessId, orderId);
     if (!row)

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

@@ -17,6 +17,7 @@ export declare function listLocalOrders(businessId: string, filters?: {
     order_type?: string;
     date_from?: string;
     date_to?: string;
+    is_paid?: string;
 }, page?: number, pageSize?: number): Promise<{
     data: import("../../types/api/seller.api").SellerOrder[];
     total: number;

package/dist/hooks/delivery.hooks.d.ts

@@ -17,6 +17,10 @@ export declare function useDeliveryDetailQuery(deliveryId: string, enabled?: boo
 export interface DeliveryFilters {
     status?: string;
     search?: string;
+    order_type?: string;
+    is_paid?: string;
+    date_from?: string;
+    date_to?: string;
 }
 export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?: DeliveryFilters): {
     dataUpdatedAt: number;

package/dist/hooks/delivery.hooks.js

@@ -34,7 +34,14 @@ function useBusinessId() {
     return id ?? undefined;
 }
 async function fetchOfflineDeliveries(businessId, filters, page, pageSize) {
-    const { data } = await listLocalOrders(businessId, { status: undefined, q: filters?.search }, page, pageSize);
+    const { data } = await listLocalOrders(businessId, {
+        status: undefined,
+        q: filters?.search,
+        order_type: filters?.order_type,
+        is_paid: filters?.is_paid,
+        date_from: filters?.date_from,
+        date_to: filters?.date_to,
+    }, page, pageSize);
     const deliveryOrders = data.filter((o) => o.delivery_id);
     const statusSet = new Set((filters?.status ?? "").split(",").map((s) => s.trim()).filter(Boolean));
     const filtered = statusSet.size > 0
@@ -73,6 +80,14 @@ export function useBusinessDeliveriesQuery(enabled = true, filters) {
                 params.status = filters.status;
             if (filters?.search)
                 params.search = filters.search;
+            if (filters?.order_type)
+                params.order_type = filters.order_type;
+            if (filters?.is_paid)
+                params.payment_status = filters.is_paid;
+            if (filters?.date_from)
+                params.date_from = filters.date_from;
+            if (filters?.date_to)
+                params.date_to = filters.date_to;
             const res = (await deliveryService.fetchBusinessDeliveries(businessId, params));
             return res;
         },

package/dist/hooks/orders.hooks.d.ts

@@ -12,11 +12,16 @@ export declare const SELLER_KEYS: {
     order: (id: string, bid?: string) => readonly ["seller", "order", string, string | undefined];
 };
 export declare function usePOSOrdersQuery(filters?: Record<string, string>, enabled?: boolean): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
-export declare function useSellerOrdersQuery(enabled?: boolean, filters?: {
+export interface SellerOrderFilters {
     status?: string;
     q?: string;
     search?: string;
-}): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
+    order_type?: string;
+    is_paid?: string;
+    date_from?: string;
+    date_to?: string;
+}
+export declare function useSellerOrdersQuery(enabled?: boolean, filters?: SellerOrderFilters): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
 export declare function useSellerOrderQuery(orderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
     data: SellerOrder;
 }, Error>;

package/dist/hooks/orders.hooks.js

@@ -58,7 +58,14 @@ export function useSellerOrdersQuery(enabled = true, filters) {
             if (!bid)
                 return { data: [], pagination: { page: 1, page_size: 20, total_pages: 1, total_entries: 0 } };
             const q = filters?.q ?? filters?.search;
-            const { data, total } = await listLocalOrders(bid, { status: filters?.status, q }, pageParam, 20);
+            const { data, total } = await listLocalOrders(bid, {
+                status: filters?.status,
+                q,
+                order_type: filters?.order_type,
+                is_paid: filters?.is_paid,
+                date_from: filters?.date_from,
+                date_to: filters?.date_to,
+            }, pageParam, 20);
             const merged = await mergePendingIntoList(data, bid, pageParam);
             const totalPages = Math.max(1, Math.ceil(total / 20));
             return { data: merged, pagination: { page: pageParam, page_size: 20, total_pages: totalPages, total_entries: total + (merged.length - data.length) } };

package/dist/index.d.ts

@@ -21,7 +21,9 @@ export * from "./utils/attempt-stats";
 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 { formatDate, formatDateTime, formatTime, formatDateCompact, formatRelativeTime } from "./utils/formatDate";
+export { resolveDateRange, DATE_PRESET_LABELS } from "./utils/date-range";
+export type { DatePreset, DateRange } from "./utils/date-range";
 export * from "./utils/validation";
 export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";

package/dist/index.js

@@ -22,7 +22,8 @@ export * from "./utils/debug-log";
 export * from "./utils/attempt-stats";
 export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
 export * from "./utils/formatCurrency";
-export { formatDate, formatRelativeTime } from "./utils/formatDate";
+export { formatDate, formatDateTime, formatTime, formatDateCompact, formatRelativeTime } from "./utils/formatDate";
+export { resolveDateRange, DATE_PRESET_LABELS } from "./utils/date-range";
 export * from "./utils/validation";
 export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";

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

@@ -15,6 +15,18 @@ declare class CommandQueueService {
     private replaying;
     private syncEngine;
     setSyncEngine(engine: SyncEngine): void;
+    /**
+     * Create-before-transition gate.
+     *
+     * A transition can only be applied to an order that exists server-side. If
+     * the `order:create` for the same entity_id is still queued, the transition
+     * must wait behind it (never POST first — that is a guaranteed 404). If the
+     * create dead-lettered, the transition can never succeed and must be failed
+     * too. A missing create row means it already synced (rows are deleted on
+     * success), so the transition may proceed.
+     */
+    orderCreateGate(businessId: string, entityId: string): Promise<"none" | "pending" | "failed">;
+    private flagOrderSyncFailed;
     /**
      * Enqueue a command because no transport is currently available.
      * Returns an optimistic domain event so the caller can update the UI.
@@ -32,6 +44,11 @@ declare class CommandQueueService {
      * permanent-rejection paths.
      */
     private failPermanently;
+    /**
+     * Dead-letter every pending transition for an entity whose parent
+     * order:create permanently failed.
+     */
+    private failDependentTransitions;
     /**
      * Already-applied absorb: pull server truth, and if the order is already
      * at this command's target status, delete the command as success. The

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

@@ -9,10 +9,11 @@
  *   - Provide optimistic domain events so the UI can render pending orders.
  */
 import { getSyncDatabase, openSyncDatabase } from "../db/connection";
-import { insertCommand, getPendingCommands, markCommandInFlight, updateCommandStatus, deleteCommand, insertEvent, } from "../db/operations";
+import { insertCommand, getPendingCommands, markCommandInFlight, updateCommandStatus, deleteCommand, insertEvent, markOrderSyncFailed, } from "../db/operations";
 import { syncLogger } from "../utils/sync-logger";
 import { recordAttempt } from "../utils/attempt-stats";
 import { TransitionError, isReplayDeferred, isReplayNoTransport, TRANSITION_ERROR_CODES } from "./transition-errors";
+import { isOrderCreate, isOrderTransition } from "./transition-endpoints";
 import { assertBusinessOpenForCreate } from "../utils/business-hours";
 import { extractApiErrorCode } from "../utils/error";
 import { generateEventId } from "../utils/uuid";
@@ -198,6 +199,51 @@ class CommandQueueService {
         }
         catch { }
     }
+    /**
+     * Create-before-transition gate.
+     *
+     * A transition can only be applied to an order that exists server-side. If
+     * the `order:create` for the same entity_id is still queued, the transition
+     * must wait behind it (never POST first — that is a guaranteed 404). If the
+     * create dead-lettered, the transition can never succeed and must be failed
+     * too. A missing create row means it already synced (rows are deleted on
+     * success), so the transition may proceed.
+     */
+    async orderCreateGate(businessId, entityId) {
+        try {
+            const db = getSyncDatabase();
+            const rows = await getPendingCommands(db, Number.MAX_SAFE_INTEGER, true);
+            let pending = false;
+            let failed = false;
+            for (const c of rows) {
+                if (c.business_id === businessId &&
+                    c.entity_id === entityId &&
+                    c.command_type === "order:create") {
+                    if (c.status === "pending" || c.status === "in_flight")
+                        pending = true;
+                    else if (c.status === "failed")
+                        failed = true;
+                }
+            }
+            if (pending)
+                return "pending";
+            if (failed)
+                return "failed";
+            return "none";
+        }
+        catch {
+            // Fail open: never brick a terminal because the DB read failed.
+            return "none";
+        }
+    }
+    async flagOrderSyncFailed(command, message) {
+        if (!command.entity_id)
+            return;
+        try {
+            await markOrderSyncFailed(getSyncDatabase(), command.business_id, command.entity_id, message);
+        }
+        catch { }
+    }
     /**
      * Enqueue a command because no transport is currently available.
      * Returns an optimistic domain event so the caller can update the UI.
@@ -263,6 +309,23 @@ class CommandQueueService {
             timestamp: command.timestamp,
             payload: command.payload,
         };
+        // Create-before-transition: never replay a transition whose parent
+        // order:create is still queued (it would 404), and fail it outright if
+        // the create already dead-lettered (it can never succeed).
+        if (isOrderTransition(command.command_type) && command.entity_id) {
+            const gate = await this.orderCreateGate(command.business_id, command.entity_id);
+            if (gate === "failed") {
+                await this.flagOrderSyncFailed(command, "Parent order creation failed");
+                await this.failPermanently(db, command, "Parent order creation failed", "parent-create-failed", {
+                    code: "PARENT_CREATE_FAILED",
+                    attempts: command.retry_count,
+                });
+                return;
+            }
+            if (gate === "pending") {
+                throw new TransitionError(TRANSITION_ERROR_CODES.REPLAY_DEFERRED, "Parent order:create still queued — deferring transition");
+            }
+        }
         if (command.retry_count >= MAX_ATTEMPTS) {
             await updateCommandStatus(db, command.command_id, "failed", "Max retry count exceeded");
             return;
@@ -385,6 +448,19 @@ class CommandQueueService {
                 }
                 catch { }
             }
+            // Transition 404: the server has no such order. The absorb above already
+            // checked the duplicate-tap / replayed-race case; if it did not apply,
+            // replaying can never create the order — fail fast instead of burning
+            // the bounded 4xx retry budget on a resource that is gone.
+            if (status === 404 && isOrderTransition(command.command_type)) {
+                await this.flagOrderSyncFailed(command, `Order not found on server (${message})`);
+                await this.failPermanently(db, command, message, "404-order-missing", {
+                    status,
+                    code,
+                    attempts: command.retry_count + 1,
+                });
+                return;
+            }
             // Every other failure is retryable on the shared 2s→5min backoff.
             //
             // 4xx (validation/permission/plan races) is bounded: a device stuck in
@@ -462,6 +538,52 @@ class CommandQueueService {
             }
         }
         catch { }
+        try {
+            if (isOrderTransition(command.command_type) || isOrderCreate(command.command_type)) {
+                await this.flagOrderSyncFailed(command, message);
+            }
+        }
+        catch { }
+        // A failed order:create strands every transition queued behind it — fail
+        // them too (they can never apply) instead of replaying them into a 404.
+        if (isOrderCreate(command.command_type) && command.entity_id) {
+            await this.failDependentTransitions(db, command, message);
+        }
+    }
+    /**
+     * Dead-letter every pending transition for an entity whose parent
+     * order:create permanently failed.
+     */
+    async failDependentTransitions(db, createCommand, message) {
+        try {
+            const pending = await getPendingCommands(db, Number.MAX_SAFE_INTEGER);
+            const rows = pending.filter((c) => c.business_id === createCommand.business_id &&
+                c.entity_id === createCommand.entity_id &&
+                c.command_type !== "order:create");
+            if (!rows.length)
+                return;
+            for (const row of rows) {
+                await updateCommandStatus(db, row.command_id, "failed", `parent_create_failed:${message}`);
+                reportSyncFailure({
+                    phase: "outbox",
+                    business_id: createCommand.business_id,
+                    user_id: createCommand.user_id,
+                    device_id: createCommand.device_id,
+                    command_type: row.command_type,
+                    command_id: row.command_id,
+                    entity_id: createCommand.entity_id,
+                    code: "PARENT_CREATE_FAILED",
+                    message,
+                    attempts: 0,
+                    terminal: true,
+                });
+            }
+            syncLogger.warn("CommandQueueService", "Dead-lettered transitions behind failed create", {
+                entity_id: createCommand.entity_id,
+                count: rows.length,
+            });
+        }
+        catch { }
     }
     /**
      * Already-applied absorb: pull server truth, and if the order is already

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 { isOrderTransition } from "./transition-endpoints";
 import { assertEntitledForCommand } from "../reference/entitlement-guard";
 import { noteRateLimited, extractRetryAfterMs } from "./rate-limit";
 function withTimeout(promise, ms) {
@@ -74,6 +75,30 @@ export class SyncEngine {
             throw new TransitionError(TRANSITION_ERROR_CODES.NO_ACTIVE_BUSINESS, "Sync requires active business and login — business_id missing or not authenticated");
         }
         syncLogger.command(command, "issued");
+        // Create-before-transition: a transition can only apply to an order that
+        // exists server-side. If its order:create is still queued, queue the
+        // transition behind it; if the create dead-lettered, discard the
+        // transition. POSTing a transition ahead of (or without) its create is a
+        // guaranteed 404 and must never happen.
+        if (isOrderTransition(command.command_type) && command.entity_id) {
+            const gate = await commandQueueService.orderCreateGate(command.business_id, command.entity_id);
+            if (gate === "failed") {
+                syncLogger.warn("SyncEngine", "Transition discarded — parent order:create failed", {
+                    command_id: command.command_id,
+                    command_type: command.command_type,
+                    entity_id: command.entity_id,
+                });
+                throw new TransitionError(TRANSITION_ERROR_CODES.ORDER_NOT_FOUND, "Parent order creation failed — transition discarded");
+            }
+            if (gate === "pending") {
+                if (opts?.forReplay) {
+                    throw new TransitionError(TRANSITION_ERROR_CODES.REPLAY_DEFERRED, "Parent order:create still queued — deferring transition");
+                }
+                const event = await commandQueueService.enqueue(command);
+                this.broadcast(event);
+                return [event];
+            }
+        }
         // Perms guard (offline-capable): block before routing
         const required = CAPABILITY_BY_COMMAND[command.command_type];
         if (required) {

package/dist/sync/sync-jobs.service.js

@@ -4,7 +4,7 @@
  * Core-only, single in_flight per business, coalesced via isOnline gate.
  */
 import { openSyncDatabase } from "../db/connection";
-import { insertOrder, getOrderById } from "../db/operations";
+import { insertOrder, getOrderById, markOrderSyncFailed } from "../db/operations";
 import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
 import { getRefreshToken, setAuthTokens, clearAuth, subscribeAuth } from "../adapters/auth";
 import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
@@ -15,7 +15,7 @@ import { recordAttempt } from "../utils/attempt-stats";
 import { BackoffTracker } from "./backoff";
 import { generateOrderNumber } from "./order-number";
 import { orderSnapshotsService } from "./order-snapshots.service";
-import { getTransitionPath, DELIVERY_COMMANDS } from "./transition-endpoints";
+import { getTransitionPath, DELIVERY_COMMANDS, isOrderTransition, isOrderCreate } from "./transition-endpoints";
 import { getQueuedStatus } from "../utils/order-transitions";
 import { extractApiErrorCode } from "../utils/error";
 import { canBusinessSync, isAuthenticated } from "./sync-guard";
@@ -294,6 +294,52 @@ async function absorbSyncJobIfApplied(db, businessId, entityId, commandType, job
     }
     return false;
 }
+/**
+ * State of the order:create sync_job for an entity, used to enforce
+ * create-before-transition. A missing row means the create already synced
+ * (rows are retained as 'completed'/'failed', so 'none' means it never
+ * existed — a cloud-pulled order — and the transition may proceed).
+ */
+async function syncJobCreateState(db, businessId, entityId) {
+    try {
+        const rows = await db.getAllAsync(`SELECT * FROM sync_jobs WHERE business_id = ?;`, businessId);
+        const creates = rows.filter((r) => r.entity_id === entityId && r.command_type === "order:create");
+        if (creates.some((r) => r.status === "pending"))
+            return "pending";
+        if (creates.some((r) => r.status === "failed"))
+            return "failed";
+        return "none";
+    }
+    catch {
+        return "none";
+    }
+}
+/** Dead-letter pending transitions for an entity whose order:create failed. */
+async function failDependentSyncJobs(db, businessId, entityId, message) {
+    try {
+        const all = await db.getAllAsync(`SELECT * FROM sync_jobs WHERE business_id = ?;`, businessId);
+        const rows = all.filter((r) => r.entity_id === entityId && r.status === "pending" && r.command_type !== "order:create");
+        const now = new Date().toISOString();
+        for (const r of rows) {
+            await db.runAsync(`UPDATE sync_jobs SET status='failed', last_error=?, updated_at=? WHERE id=?;`, `parent_create_failed:${message}`, now, r.id);
+            reportSyncFailure({
+                phase: "sync_jobs",
+                business_id: businessId,
+                command_type: r.command_type,
+                command_id: r.id,
+                entity_id: entityId,
+                code: "PARENT_CREATE_FAILED",
+                message,
+                attempts: r.attempts,
+                terminal: true,
+            });
+        }
+        if (rows.length) {
+            syncLogger.warn("SyncJobs", "Dead-lettered transitions behind failed create", { businessId, entityId, count: rows.length });
+        }
+    }
+    catch { }
+}
 export async function drainOne(businessId, entityId) {
     if (!businessId || !canBusinessSync(businessId)) {
         syncLogger.debug("SyncJobs", "drainOne early-return — no business/auth", { businessId, entityId });
@@ -340,6 +386,32 @@ export async function drainOne(businessId, entityId) {
             return;
         }
         const payload = JSON.parse(row.payload);
+        // Create-before-transition: a transition whose parent order:create has
+        // dead-lettered can never apply — fail it now rather than POSTing to a
+        // guaranteed 404. A still-pending create (defensive: FIFO normally drains
+        // it first) defers the transition.
+        if (isOrderTransition(row.command_type) && row.entity_id) {
+            const createState = await syncJobCreateState(db, businessId, row.entity_id);
+            if (createState === "failed") {
+                await db.runAsync(`UPDATE sync_jobs SET status='failed', last_error=?, updated_at=? WHERE id=?;`, "parent_create_failed", new Date().toISOString(), row.id);
+                try {
+                    await markOrderSyncFailed(db, businessId, row.entity_id, "Parent order creation failed");
+                }
+                catch { }
+                reportJobFailure(businessId, row, { code: "PARENT_CREATE_FAILED", message: "Parent order creation failed", attempts: row.attempts, terminal: true });
+                try {
+                    const { notifyError } = await import("../adapters/notify");
+                    notifyError(`Order creation failed — discarded a follow-up ${row.command_type}`);
+                }
+                catch { }
+                return;
+            }
+            if (createState === "pending") {
+                syncLogger.debug("SyncJobs", "Transition waiting on pending create", { businessId, entityId });
+                scheduleRetry(businessId);
+                return;
+            }
+        }
         // 1) PHX first (only when cloud reachable)
         let phxOk = false;
         if (isOnlineForPhx()) {
@@ -478,6 +550,28 @@ export async function drainOne(businessId, entityId) {
             }
             catch { }
         }
+        // Transition 404: the server has no such order. Absorb above checked the
+        // already-applied race; if it did not apply, replaying can never create the
+        // order — dead-letter immediately instead of burning the 4xx retry budget.
+        if (rest.status === 404 && isOrderTransition(row.command_type)) {
+            syncLogger.warn("SyncJobs", "Transition 404 — order missing, failing job", { businessId, entityId, command_type: row.command_type });
+            try {
+                await db.runAsync(`UPDATE sync_jobs SET status='failed', last_error=?, updated_at=? WHERE id=?;`, `404 ${rest.code ?? ""} ${rest.message ?? ""}`.trim(), new Date().toISOString(), row.id);
+            }
+            catch { }
+            try {
+                await markOrderSyncFailed(db, businessId, row.entity_id, `Order not found on server (${rest.message ?? rest.code ?? "404"})`);
+            }
+            catch { }
+            reportJobFailure(businessId, row, { status: 404, code: rest.code ?? "NOT_FOUND", message: rest.message, attempts: (row.attempts ?? 0) + 1, terminal: true });
+            clearRetry(businessId);
+            try {
+                const { notifyError } = await import("../adapters/notify");
+                notifyError(`Order no longer exists on server — dropped ${row.command_type}`);
+            }
+            catch { }
+            return;
+        }
         if (isBusinessClosed) {
             syncLogger.warn("SyncJobs", "Business closed — keeping pending for retry after hours sync", { businessId, entityId, code: rest.code });
             reportJobFailure(businessId, row, { status: rest.status, code: rest.code, message: rest.message, attempts: row.attempts, terminal: false });
@@ -505,6 +599,14 @@ export async function drainOne(businessId, entityId) {
             catch { }
             reportJobFailure(businessId, row, { status: rest.status, code: rest.code, message: rest.message, attempts, terminal: true });
             clearRetry(businessId);
+            // A dead-lettered order:create strands every transition behind it.
+            if (isOrderCreate(row.command_type)) {
+                try {
+                    await markOrderSyncFailed(db, businessId, row.entity_id, rest.message ?? "Order creation failed");
+                }
+                catch { }
+                await failDependentSyncJobs(db, businessId, row.entity_id, rest.message ?? "Order creation failed");
+            }
             try {
                 const { notifyError } = await import("../adapters/notify");
                 notifyError(`Server rejected ${row.command_type}: ${rest.message ?? rest.code ?? rest.status} (after retries)`);

package/dist/sync/transition-endpoints.d.ts

@@ -11,6 +11,16 @@
  */
 /** Command types fulfilled by the delivery endpoints (strictly online). */
 export declare const DELIVERY_COMMANDS: Set<string>;
+/**
+ * Order-scoped transitions. Every one of these operates on an order that must
+ * already exist server-side (the `order:create` for the same entity_id must
+ * have landed). Used to enforce create-before-transition ordering and to make
+ * a 404 on a transition terminal instead of a blind retry: a transition whose
+ * order is gone can never succeed by being replayed.
+ */
+export declare const ORDER_TRANSITION_COMMANDS: Set<string>;
+export declare function isOrderCreate(commandType: string): boolean;
+export declare function isOrderTransition(commandType: string): boolean;
 /**
  * Build the REST path for a given command type and order/delivery ID.
  * Returns null for unknown command types AND for delivery commands, which

package/dist/sync/transition-endpoints.js

@@ -26,6 +26,30 @@ export const DELIVERY_COMMANDS = new Set([
     "order:assign_rider",
     "order:confirm_handover",
 ]);
+/**
+ * Order-scoped transitions. Every one of these operates on an order that must
+ * already exist server-side (the `order:create` for the same entity_id must
+ * have landed). Used to enforce create-before-transition ordering and to make
+ * a 404 on a transition terminal instead of a blind retry: a transition whose
+ * order is gone can never succeed by being replayed.
+ */
+export const ORDER_TRANSITION_COMMANDS = new Set([
+    "order:accept",
+    "order:reject",
+    "order:start_preparing",
+    "order:mark_ready",
+    "order:complete_pickup",
+    "order:cancel",
+    "order:confirm_cash",
+    "order:pay",
+    "payment:confirm_cash",
+]);
+export function isOrderCreate(commandType) {
+    return commandType === "order:create";
+}
+export function isOrderTransition(commandType) {
+    return ORDER_TRANSITION_COMMANDS.has(commandType);
+}
 /**
  * Build the REST path for a given command type and order/delivery ID.
  * Returns null for unknown command types AND for delivery commands, which

package/dist/test-helpers/memory-driver.js

@@ -277,6 +277,15 @@ export function createMemoryDriver() {
                 }
                 return { lastInsertRowId: 0, changes: 1 };
             }
+            if (s.includes("UPDATE orders SET sync_failed_at = ?")) {
+                const [sync_failed_at, sync_error, business_id, id1, id2] = args;
+                const row = tables.orders.find((r) => r.business_id === business_id && (r.id === id1 || r.order_number === id2));
+                if (row) {
+                    row.sync_failed_at = sync_failed_at;
+                    row.sync_error = sync_error;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
             // cleanup deletes for v7
             if (s.includes("DELETE FROM orders WHERE order_number = '[object Object]'")) {
                 const before = tables.orders.length;
@@ -401,24 +410,61 @@ export function createMemoryDriver() {
                     rows = rows.slice(0, limit);
                 return rows;
             }
-            // orders list with filters (simple business_id filter + pagination)
+            // orders list with filters (business_id + status/order_type/is_paid/q/date)
             if (s.includes("SELECT * FROM orders WHERE")) {
                 const business_id = args[0];
-                // args includes where-clause params plus LIMIT and OFFSET at end
-                // For test, just filter by business_id and apply basic status/q if present in sql string via args slicing?
-                // Simpler: return all orders for that business, sorted by inserted_at desc, handle LIMIT/OFFSET manually
                 let rows = tables.orders.filter((r) => r.business_id === business_id);
-                // handle status filter if sql contains status IN
+                // Consume filter args in the exact clause order produced by listOrders.
+                let i = 1;
                 if (s.includes("status IN")) {
-                    // find args that are status values (excluding business_id, limit, offset)
-                    // Our sql: SELECT * FROM orders WHERE business_id = ? AND status IN (?,?) ... LIMIT ? OFFSET ?
-                    // So statuses are args[1]..args[?]
-                    // Count statuses by parsing SQL placeholder count?
-                    // For test, just extract known statuses from args that look like status strings
-                    const possibleStatuses = ["pending", "awaiting_payment", "accepted", "preparing", "ready", "waiting_pickup", "on_the_way", "arrived", "delivered", "cancelled", "assigned", "picked_up", "en_route", "failed"];
-                    const statusArgs = args.filter((v) => possibleStatuses.includes(String(v)));
-                    if (statusArgs.length)
-                        rows = rows.filter((r) => statusArgs.includes(r.status));
+                    const n = (s.match(/status IN \([^)]*\)/)[0].match(/\?/g) || []).length;
+                    const statuses = args.slice(i, i + n);
+                    i += n;
+                    if (statuses.length)
+                        rows = rows.filter((r) => statuses.includes(r.status));
+                }
+                if (s.includes("is_pos = ?")) {
+                    const v = Number(args[i++]) === 1;
+                    rows = rows.filter((r) => !!r.is_pos === v);
+                }
+                if (s.includes("order_type = ?")) {
+                    const t = args[i++];
+                    rows = rows.filter((r) => r.order_type === t);
+                }
+                if (s.includes("json_extract(payment, '$.is_paid') = 1")) {
+                    rows = rows.filter((r) => {
+                        try {
+                            return JSON.parse(r.payment ?? "{}").is_paid === true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                }
+                else if (s.includes("json_extract(payment, '$.is_paid') IS NULL")) {
+                    rows = rows.filter((r) => {
+                        try {
+                            return JSON.parse(r.payment ?? "{}").is_paid !== true;
+                        }
+                        catch {
+                            return true;
+                        }
+                    });
+                }
+                if (s.includes("order_number LIKE ?")) {
+                    const term = String(args[i]).replace(/%/g, "").toLowerCase();
+                    i += 3;
+                    rows = rows.filter((r) => String(r.order_number ?? "").toLowerCase().includes(term) ||
+                        String(r.customer_name ?? "").toLowerCase().includes(term) ||
+                        String(r.customer_phone ?? "").toLowerCase().includes(term));
+                }
+                if (s.includes("inserted_at >= ?")) {
+                    const from = String(args[i++]);
+                    rows = rows.filter((r) => String(r.inserted_at) >= from);
+                }
+                if (s.includes("inserted_at < ?")) {
+                    const to = String(args[i++]);
+                    rows = rows.filter((r) => String(r.inserted_at) < to);
                 }
                 rows = rows.sort((a, b) => (a.inserted_at < b.inserted_at ? 1 : -1));
                 const limit = args[args.length - 2];

package/dist/utils/date-range.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Date-range presets for order/delivery filters.
+ *
+ * Returns YYYY-MM-DD strings (local day boundaries) that both the backend
+ * (normalizes to UTC day bounds) and the local SQLite read-model
+ * (`inserted_at >= from` / `inserted_at < `${to}T23:59:59``) accept.
+ */
+export type DatePreset = "all" | "today" | "yesterday" | "last7" | "custom";
+export interface DateRange {
+    date_from?: string;
+    date_to?: string;
+}
+export declare function resolveDateRange(preset: DatePreset | string | undefined, customFrom?: string, customTo?: string): DateRange;
+export declare const DATE_PRESET_LABELS: Array<{
+    key: DatePreset;
+    label: string;
+}>;

package/dist/utils/date-range.js

@@ -0,0 +1,45 @@
+/**
+ * Date-range presets for order/delivery filters.
+ *
+ * Returns YYYY-MM-DD strings (local day boundaries) that both the backend
+ * (normalizes to UTC day bounds) and the local SQLite read-model
+ * (`inserted_at >= from` / `inserted_at < `${to}T23:59:59``) accept.
+ */
+function toISODate(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+function addDays(base, days) {
+    const d = new Date(base);
+    d.setDate(d.getDate() + days);
+    return d;
+}
+export function resolveDateRange(preset, customFrom, customTo) {
+    const today = new Date();
+    switch (preset) {
+        case "today":
+            return { date_from: toISODate(today), date_to: toISODate(today) };
+        case "yesterday": {
+            const y = toISODate(addDays(today, -1));
+            return { date_from: y, date_to: y };
+        }
+        case "last7":
+            return { date_from: toISODate(addDays(today, -6)), date_to: toISODate(today) };
+        case "custom":
+            return {
+                ...(customFrom ? { date_from: customFrom } : {}),
+                ...(customTo ? { date_to: customTo } : {}),
+            };
+        default:
+            return {};
+    }
+}
+export const DATE_PRESET_LABELS = [
+    { key: "all", label: "All time" },
+    { key: "today", label: "Today" },
+    { key: "yesterday", label: "Yesterday" },
+    { key: "last7", label: "Last 7 days" },
+    { key: "custom", label: "Custom" },
+];

package/dist/utils/formatDate.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Format the time-of-day of an ISO date string (e.g. "2:30 PM").
+ */
+export declare function formatTime(isoString: string): string;
+/**
+ * Compact date (e.g. "26 Sep 2026") for list cards where the year may be
+ * implied but is still useful for older orders.
+ */
+export declare function formatDateCompact(isoString: string): string;
+/**
+ * Date + time for order/delivery cards: "26 Sep 2026, 2:30 PM".
+ */
+export declare function formatDateTime(isoString: string): string;
 /**
  * Format an ISO date string into a human-readable format.
  */

package/dist/utils/formatDate.js

@@ -1,3 +1,32 @@
+/**
+ * Format the time-of-day of an ISO date string (e.g. "2:30 PM").
+ */
+export function formatTime(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true,
+    });
+}
+/**
+ * Compact date (e.g. "26 Sep 2026") for list cards where the year may be
+ * implied but is still useful for older orders.
+ */
+export function formatDateCompact(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleDateString('en-US', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+    });
+}
+/**
+ * Date + time for order/delivery cards: "26 Sep 2026, 2:30 PM".
+ */
+export function formatDateTime(isoString) {
+    return `${formatDateCompact(isoString)}, ${formatTime(isoString)}`;
+}
 /**
  * Format an ISO date string into a human-readable format.
  */

package/package.json

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