@teincfood/core 0.9.18 → 0.9.19

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;
@@ -84,6 +86,12 @@ export declare function listOrders(db: SQLiteDatabase, businessId: string, filte
     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");
 }
@@ -286,6 +288,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/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;

package/package.json

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