@burdenoff/microfe-movethewheels 2026.1016.12 → 2026.1017.1

package/dist/utils/graphqlClient.js

@@ -1,103 +1,110 @@
-import { prepareWorkspaceRequest as e } from "@burdenoff/fe-libs/shared/graphql";
+import { vehicleHoldRefusal as e } from "./orderVehicleHold.js";
+import { prepareWorkspaceRequest as t } from "@burdenoff/fe-libs/shared/graphql";
 //#region src/movethewheels/utils/graphqlClient.ts
-function t(e) {
+function n(e) {
 	return e ? e.endsWith("/graphql") ? e : `${e}/workspaces/graphql` : "/workspaces/graphql";
 }
-var n = 3, r = 12e3;
-function i(e) {
+var r = 3, i = 12e3;
+function a(e) {
 	return e ? /upstream connect|connection refused|reset before headers|delayed connect|econnrefused|econnreset|socket hang up|service unavailable|bad gateway|gateway timeout|temporarily unavailable|please try again|failed to fetch|networkerror|load failed/i.test(e) : !1;
 }
-function a(e) {
+function o(e) {
 	return e === 429 || e === 502 || e === 503 || e === 504;
 }
-function o(e) {
+function s(e) {
 	return typeof e == "object" && !!e && "name" in e && e.name === "AbortError";
 }
-var s = (e) => new Promise((t) => setTimeout(t, e)), c = 4, l = 0, u = [];
-function d() {
+var c = (e) => new Promise((t) => setTimeout(t, e)), l = 4, u = 0, d = [];
+function f() {
 	return new Promise((e) => {
-		l < c ? (l += 1, e()) : u.push(e);
+		u < l ? (u += 1, e()) : d.push(e);
 	});
 }
-function f() {
-	let e = u.shift();
-	e ? e() : --l;
+function p() {
+	let e = d.shift();
+	e ? e() : --u;
 }
-async function p(r, i, a, o = "RETRY_TRANSIENT") {
-	let s = { ...r }, c = JSON.stringify({
+async function m(e, i, a, o = "RETRY_TRANSIENT", s) {
+	let c = { ...e }, l = JSON.stringify({
 		query: i,
 		variables: a
-	}), l = t(s.apiGatewayUrl);
-	await d();
+	}), u = n(c.apiGatewayUrl);
+	await f();
 	try {
-		let t = typeof window < "u" ? await e({
-			url: new URL(l, typeof document < "u" && document.baseURI || window.location.href).toString(),
-			authToken: s.authToken ?? "",
-			actorId: s.actorId ?? "",
-			workspaceId: s.workspaceId ?? "",
-			tenantId: s.tenantId,
-			workspaceToken: s.workspaceToken,
+		let e = typeof window < "u" ? await t({
+			url: new URL(u, typeof document < "u" && document.baseURI || window.location.href).toString(),
+			authToken: c.authToken ?? "",
+			actorId: c.actorId ?? "",
+			workspaceId: c.workspaceId ?? "",
+			tenantId: c.tenantId,
+			workspaceToken: c.workspaceToken,
 			currentQuery: i
-		}) : null, r = t?.workspaceToken ?? s.workspaceToken;
-		return await h(l, {
+		}) : null, n = e?.workspaceToken ?? c.workspaceToken;
+		return await _(u, {
 			"content-type": "application/json",
-			...s.authToken ? { Authorization: `Bearer ${s.authToken}` } : {},
-			...r ? { "X-Workspace-Authorization": `Bearer ${r}` } : {},
-			...s.workspaceId ? { "x-workspace-id": s.workspaceId } : {},
-			...s.tenantId ? { "x-tenant-id": s.tenantId } : {},
-			...s.actorId ? { "x-actor-id": s.actorId } : {},
-			...s.actorId ? { "x-actor-type": "user" } : {}
-		}, c, o === "SINGLE_ATTEMPT" ? 0 : n, t?.assertCurrent ?? (() => {}));
+			...c.authToken ? { Authorization: `Bearer ${c.authToken}` } : {},
+			...n ? { "X-Workspace-Authorization": `Bearer ${n}` } : {},
+			...c.workspaceId ? { "x-workspace-id": c.workspaceId } : {},
+			...c.tenantId ? { "x-tenant-id": c.tenantId } : {},
+			...c.actorId ? { "x-actor-id": c.actorId } : {},
+			...c.actorId ? { "x-actor-type": "user" } : {}
+		}, l, o === "SINGLE_ATTEMPT" ? 0 : r, e?.assertCurrent ?? (() => {}), o === "SINGLE_ATTEMPT" ? s : void 0);
 	} finally {
-		f();
+		p();
 	}
 }
-async function m(e) {
+async function h(t, n) {
 	try {
-		let t = ((await e.json()).errors ?? []).map((e) => e.message).filter((e) => typeof e == "string" && e.length > 0);
-		return t.length > 0 ? t.join("; ") : null;
+		let r = await t.json(), i = e(r, t.status, n);
+		if (i) return i;
+		let a = (r.errors ?? []).map((e) => e.message).filter((e) => typeof e == "string" && e.length > 0);
+		return a.length > 0 ? Error(a.join("; ")) : null;
 	} catch {
 		return null;
 	}
 }
-async function h(e, t, n, c, l) {
-	let u = /* @__PURE__ */ Error("GraphQL request failed");
-	for (let d = 0; d <= c; d += 1) {
-		let f = d < c;
-		d > 0 && await s(Math.min(250 * 2 ** (d - 1), 2e3) + Math.floor(Math.random() * 150)), l();
-		let p = new AbortController(), h = setTimeout(() => p.abort(), r);
+function g(e, t) {
+	return typeof e != "object" || !e || Array.isArray(e) || "errors" in e && (!Array.isArray(e.errors) || e.errors.length !== 0) || !("data" in e) || typeof e.data != "object" || e.data === null || Array.isArray(e.data) ? !1 : Object.keys(e.data).length === 1 && Object.hasOwn(e.data, t);
+}
+async function _(t, n, r, l, u, d) {
+	let f = /* @__PURE__ */ Error("GraphQL request failed");
+	for (let p = 0; p <= l; p += 1) {
+		let m = p < l;
+		p > 0 && await c(Math.min(250 * 2 ** (p - 1), 2e3) + Math.floor(Math.random() * 150)), u();
+		let _ = new AbortController(), v = setTimeout(() => _.abort(), i);
 		try {
-			let r = await fetch(e, {
+			let i = await fetch(t, {
 				method: "POST",
-				headers: t,
-				body: n,
-				signal: p.signal
+				headers: n,
+				body: r,
+				signal: _.signal
 			});
-			if (!r.ok) {
-				let e = a(r.status) ? null : await m(r);
-				if (u = Error(e ?? `GraphQL request failed with status ${r.status}`), f && a(r.status)) continue;
-				throw u;
+			if (!i.ok) {
+				if (f = (o(i.status) ? null : await h(i, d)) ?? /* @__PURE__ */ Error(`GraphQL request failed with status ${i.status}`), m && o(i.status)) continue;
+				throw f;
 			}
-			let o = await r.json();
-			if (o.errors?.length) {
-				let e = o.errors.map((e) => e.message ?? "Unknown GraphQL error").join("; ");
-				if (u = Error(e), f && o.errors.some((e) => i(e.message))) continue;
-				throw u;
+			let s = await i.json(), c = e(s, i.status, d);
+			if (c) throw c;
+			if (d && !g(s, d)) throw Error("The order write response could not be confirmed.");
+			if (s.errors?.length) {
+				let e = s.errors.map((e) => e.message ?? "Unknown GraphQL error").join("; ");
+				if (f = Error(e), m && s.errors.some((e) => a(e.message))) continue;
+				throw f;
 			}
-			if (!o.data) {
-				if (u = /* @__PURE__ */ Error("GraphQL response did not include data"), f) continue;
-				throw u;
+			if (!s.data) {
+				if (f = /* @__PURE__ */ Error("GraphQL response did not include data"), m) continue;
+				throw f;
 			}
-			return o.data;
+			return s.data;
 		} catch (e) {
-			let t = o(e), n = t ? `GraphQL request timed out after ${r}ms` : e instanceof Error ? e.message : String(e);
-			if (u = !t && e instanceof Error ? e : Error(n), f && (t || i(n) || e instanceof TypeError)) continue;
-			throw u;
+			let t = s(e), n = t ? `GraphQL request timed out after ${i}ms` : e instanceof Error ? e.message : String(e);
+			if (f = !t && e instanceof Error ? e : Error(n), m && (t || a(n) || e instanceof TypeError)) continue;
+			throw f;
 		} finally {
-			clearTimeout(h);
+			clearTimeout(v);
 		}
 	}
-	throw u;
+	throw f;
 }
 //#endregion
-export { p as executeGraphQL, t as resolveGraphqlUrl };
+export { m as executeGraphQL, n as resolveGraphqlUrl };

package/dist/utils/orderVehicleHold.js

@@ -0,0 +1,38 @@
+//#region src/movethewheels/utils/orderVehicleHold.ts
+var e = class extends Error {
+	operation;
+	kind;
+	constructor(e, t = "vehicle") {
+		super("The recorded eligibility prevents this assignment or movement."), this.operation = e, this.kind = t, this.name = "VehicleHoldRefusal";
+	}
+};
+function t(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function n(n, r, i) {
+	if (!i || r !== 200 && r !== 400 || !t(n) || !Array.isArray(n.errors) || n.errors.length !== 1) return null;
+	let a = n.errors[0];
+	if (!t(a) || typeof a.message != "string" || !a.message || !Array.isArray(a.path) || a.path.length !== 1 || a.path[0] !== i || !t(a.extensions) || a.extensions.code !== "BAD_USER_INPUT") return null;
+	let o = a.extensions.i18nKey, s = o === "route.errors.vehicleNotAssignable" ? "vehicle" : o === "route.errors.driverInactive" || o === "route.errors.driverLicenseUnknown" || o === "route.errors.driverLicenseExpired" ? "driver" : null;
+	return !s || n.data !== void 0 && n.data !== null && (!t(n.data) || Object.keys(n.data).length !== 1 || n.data[i] !== null) ? null : new e(i, s);
+}
+var r = new Set([
+	"PENDING",
+	"CONFIRMED",
+	"ASSIGNED",
+	"PICKED_UP",
+	"IN_TRANSIT",
+	"OUT_FOR_DELIVERY",
+	"DELIVERED",
+	"RETURNED",
+	"CANCELLED",
+	"FAILED"
+]);
+function i(e, n) {
+	if (!t(e) || e.id !== n.id || typeof e.status != "string" || !r.has(e.status) || n.vehicleId !== void 0 && e.vehicleId !== n.vehicleId || n.driverId !== void 0 && e.driverId !== n.driverId || n.status !== void 0 && e.status !== n.status) throw Error("The order write could not be confirmed.");
+}
+function a(e) {
+	return e === "available" || e === "assigned";
+}
+//#endregion
+export { e as VehicleHoldRefusal, i as assertOrderAcknowledgement, a as isVehicleAssignable, n as vehicleHoldRefusal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/microfe-movethewheels",
-  "version": "2026.1016.12",
+  "version": "2026.1017.1",
   "description": "Burdenoff MoveTheWheels Microfrontend - Logistics & Supply Chain Management Platform",
   "type": "module",
   "files": [
@@ -26,6 +26,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
+    "verify:order-vehicle-hold": "bun test scripts/check-order-vehicle-hold.test.ts && bun scripts/verify-order-dispatch.mjs",
     "verify:workspace-predispatch": "bun test scripts/verify-workspace-predispatch.test.ts",
     "verify:multimodal-single-attempt": "bun scripts/verify-multimodal-single-attempt.mjs",
     "verify:live-logistics-contract": "bun test scripts/check-logistics-live-contract.test.mjs scripts/fetch-logistics-live-schema.test.mjs",
@@ -36,7 +37,7 @@
     "format": "prettier --write \"src/**/*.{ts,tsx}\"",
     "type:check": "bash scripts/build-limits.sh tsc --noEmit",
     "validate:schema-drift": "graphql-schema-drift",
-    "sanity": "bash scripts/build-limits.sh --gate bash -c 'bun run codegen && bun run validate:schema-drift && bun run lint:sanity && bun run format && bun run type:check && bun run verify:live-logistics-contract && bun run verify:empty-reuse-retry && bun run verify:empty-reuse-recovery && bun run verify:trip-utilization-input && bun run verify:trip-draft-context && bun run verify:stock-binding-input && bun run verify:stock-observation-input && bun run verify:pending-pick-input && bun run verify:pick-review-ack && bun run verify:driver-license-expiry && bun run verify:freight-input && bun run verify:freight-recovery && bun run verify:freight-commercial && bun run verify:freight-invoice && bun run verify:procedure-input && bun run verify:consolidation && bun run verify:multimodal-single-attempt && bun run verify:workspace-predispatch && bun run verify:tracking-quality-outcomes && bun run verify:shipment-status-authority && bun run verify:free-time-permissions && bun run verify:core-codegen && bun run build && bun run build-storybook'",
+    "sanity": "bash scripts/build-limits.sh --gate bash -c 'bun run codegen && bun run validate:schema-drift && bun run lint:sanity && bun run format && bun run type:check && bun run verify:live-logistics-contract && bun run verify:empty-reuse-retry && bun run verify:empty-reuse-recovery && bun run verify:trip-utilization-input && bun run verify:trip-draft-context && bun run verify:stock-binding-input && bun run verify:stock-observation-input && bun run verify:pending-pick-input && bun run verify:pick-review-ack && bun run verify:driver-license-expiry && bun run verify:freight-input && bun run verify:freight-recovery && bun run verify:freight-commercial && bun run verify:freight-invoice && bun run verify:procedure-input && bun run verify:consolidation && bun run verify:multimodal-single-attempt && bun run verify:workspace-predispatch && bun run verify:tracking-quality-outcomes && bun run verify:shipment-status-authority && bun run verify:free-time-permissions && bun run verify:core-codegen && bun run verify:order-vehicle-hold && bun run build && bun run build-storybook'",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
     "test:storybook": "vitest run --project=storybook",

package/src/movethewheels/hooks/useFleet.ts

@@ -1161,6 +1161,15 @@ export function useVehicle(vehicleId: string | undefined) {
           id: vehicleId,
         }
       );
+      if (
+        data.vehicle &&
+        (data.vehicle.id !== vehicleId ||
+          !['ACTIVE', 'IN_TRANSIT', 'MAINTENANCE', 'INACTIVE', 'DECOMMISSIONED'].includes(
+            data.vehicle.status
+          ))
+      ) {
+        throw new Error('Vehicle status could not be verified.');
+      }
       setVehicle(data.vehicle ? mapVehicle(data.vehicle) : null);
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load vehicle'));

package/src/movethewheels/hooks/useOrderDispatch.ts

@@ -0,0 +1,196 @@
+import { useEffect, useRef, useState } from 'react';
+import type { Order, OrderStatus } from '../types';
+import type { OrderWriteInput } from './useOrders';
+import { VehicleHoldRefusal } from '../utils/orderVehicleHold';
+import { useTr } from '../shared/hooks/useTr';
+
+interface DispatchOptions {
+  order: Order | null;
+  contextKey: string;
+  ready: boolean;
+  assignmentReady: boolean;
+  movementReady: boolean;
+  updateOrder: (
+    id: string,
+    input: OrderWriteInput,
+    attemptPolicy: 'SINGLE_ATTEMPT'
+  ) => Promise<Order>;
+  updateOrderStatus: (id: string, status: OrderStatus) => Promise<Order>;
+  refresh: () => void;
+}
+
+/** One order/context only. Storage retains uncertainty, never a replayable request or token. */
+export function useOrderDispatch(options: DispatchOptions) {
+  const tr = useTr();
+  const { order, contextKey, updateOrder, updateOrderStatus, refresh } = options;
+  const storageKey = `movethewheels.order-dispatch.unconfirmed.v1:${contextKey}`;
+  const [blocked, setBlocked] = useState(() => {
+    try {
+      return sessionStorage.getItem(storageKey) !== null;
+    } catch {
+      return true;
+    }
+  });
+  const [busy, setBusy] = useState(false);
+  const [message, setMessage] = useState<string | null>(null);
+  const [knownAssignment, setKnownAssignment] = useState<{
+    orderId: string;
+    vehicleId: string;
+    driverId: string;
+  } | null>(null);
+  const running = useRef(false);
+  const active = useRef(true);
+  useEffect(() => {
+    active.current = true;
+    return () => {
+      active.current = false;
+    };
+  }, []);
+  const uncertain = (assignmentSaved: boolean) =>
+    tr(
+      assignmentSaved
+        ? 'movethewheels.order.movementUnknown'
+        : 'movethewheels.order.assignmentUnknown',
+      assignmentSaved
+        ? 'Assignment saved. Movement could not be confirmed. Further changes are blocked.'
+        : 'Assignment could not be confirmed. Further changes are blocked. Check the order before taking another action.'
+    );
+  const retain = () => {
+    // Recheck storage synchronously so a second mounted view cannot bypass a pending write.
+    if (sessionStorage.getItem(storageKey) !== null) throw new Error('Unconfirmed order write');
+    sessionStorage.setItem(storageKey, 'unconfirmed');
+  };
+  const confirm = () => sessionStorage.removeItem(storageKey);
+  const begin = (allowed: boolean) => {
+    if (running.current || blocked || !active.current || !options.ready || !allowed || !order)
+      return false;
+    try {
+      retain();
+    } catch {
+      setBlocked(true);
+      setMessage(
+        tr(
+          'movethewheels.order.retentionUnavailable',
+          'Further changes are blocked because this browser cannot safely retain the order write.'
+        )
+      );
+      return false;
+    }
+    running.current = true;
+    setBusy(true);
+    setMessage(null);
+    return true;
+  };
+  const finish = () => {
+    running.current = false;
+    if (active.current) setBusy(false);
+  };
+  const assign = async (vehicleId: string, driverId: string) => {
+    if (
+      !vehicleId ||
+      !driverId ||
+      !order ||
+      (order.vehicleId === vehicleId && order.driverId === driverId) ||
+      !begin(options.assignmentReady)
+    )
+      return;
+    let assignmentSaved = false;
+    try {
+      await updateOrder(order.id, { vehicleId, driverId }, 'SINGLE_ATTEMPT');
+      assignmentSaved = true;
+      if (active.current) setKnownAssignment({ orderId: order.id, vehicleId, driverId });
+      confirm();
+      if (!active.current) return;
+      const advance = !(order.vehicleId && order.driverId) && order.status === 'confirmed';
+      if (advance) {
+        retain();
+        await updateOrderStatus(order.id, 'assigned');
+        confirm();
+      }
+      if (!active.current) return;
+      setMessage(tr('movethewheels.order.assignmentSaved', 'Assignment saved.'));
+      refresh();
+    } catch (error) {
+      // The opt-in transport classifier is the only known pre-write refusal.
+      if (
+        error instanceof VehicleHoldRefusal &&
+        error.operation === (assignmentSaved ? 'updateDeliveryJobStatus' : 'updateDeliveryJob')
+      ) {
+        try {
+          confirm();
+        } catch {
+          if (active.current) setBlocked(true);
+        }
+        if (!active.current) return;
+        setMessage(
+          tr(
+            error.kind === 'driver'
+              ? assignmentSaved
+                ? 'movethewheels.order.driverMovementBlocked'
+                : 'movethewheels.order.driverAssignmentBlocked'
+              : assignmentSaved
+                ? 'movethewheels.order.movementBlocked'
+                : 'movethewheels.order.assignmentBlocked',
+            error.kind === 'driver'
+              ? assignmentSaved
+                ? 'Assignment saved. Driver eligibility blocked movement.'
+                : 'Assignment blocked by driver eligibility. Choose another driver.'
+              : assignmentSaved
+                ? 'Assignment saved. Movement blocked.'
+                : 'Assignment blocked by the recorded vehicle status. Choose another vehicle.'
+          )
+        );
+        refresh();
+      } else if (active.current) {
+        setBlocked(true);
+        setMessage(uncertain(assignmentSaved));
+      }
+    } finally {
+      finish();
+    }
+  };
+  const changeStatus = async (status: OrderStatus) => {
+    if (!order || ['delivered', 'returned', 'cancelled', 'failed'].includes(order.status)) return;
+    if (status === 'assigned' && (!order.vehicleId || !order.driverId)) return;
+    const movement = ['assigned', 'picked_up', 'in_transit', 'out_for_delivery'].includes(status);
+    if (!begin(!movement || options.movementReady) || !order) return;
+    try {
+      await updateOrderStatus(order.id, status);
+      confirm();
+      if (!active.current) return;
+      setMessage(tr('movethewheels.order.statusSaved', 'Order status updated.'));
+      refresh();
+    } catch (error) {
+      if (error instanceof VehicleHoldRefusal && error.operation === 'updateDeliveryJobStatus') {
+        try {
+          confirm();
+        } catch {
+          if (active.current) setBlocked(true);
+        }
+        if (!active.current) return;
+        setMessage(
+          tr(
+            error.kind === 'driver'
+              ? 'movethewheels.order.driverStatusBlocked'
+              : 'movethewheels.order.statusBlocked',
+            error.kind === 'driver'
+              ? 'Movement blocked by driver eligibility. Choose another driver.'
+              : 'Movement blocked by the recorded vehicle status. Choose another vehicle.'
+          )
+        );
+        refresh();
+      } else if (active.current) {
+        setBlocked(true);
+        setMessage(
+          tr(
+            'movethewheels.order.statusUnknown',
+            'Order status could not be confirmed. Further changes are blocked.'
+          )
+        );
+      }
+    } finally {
+      finish();
+    }
+  };
+  return { assign, changeStatus, busy, blocked, message, knownAssignment };
+}

package/src/movethewheels/hooks/useOrders.ts

@@ -2,7 +2,8 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
 import type { Order, OrderFilter, OrderStatus } from '../types';
 import { mapRoute } from './useRoutes';
-import { executeGraphQL } from '../utils/graphqlClient';
+import { executeGraphQL, type GraphQLAttemptPolicy } from '../utils/graphqlClient';
+import { assertOrderAcknowledgement } from '../utils/orderVehicleHold';
 
 interface UseOrdersOptions {
   filters?: OrderFilter;
@@ -30,7 +31,11 @@ interface UseOrdersResult {
   error: Error | null;
   refetch: () => void;
   createOrder: (order: OrderWriteInput) => Promise<Order>;
-  updateOrder: (id: string, updates: OrderWriteInput) => Promise<Order>;
+  updateOrder: (
+    id: string,
+    updates: OrderWriteInput,
+    attemptPolicy?: GraphQLAttemptPolicy
+  ) => Promise<Order>;
   deleteOrder: (id: string) => Promise<void>;
   updateOrderStatus: (id: string, status: OrderStatus) => Promise<Order>;
 }
@@ -462,30 +467,47 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
   );
 
   const updateOrder = useCallback(
-    async (id: string, updates: OrderWriteInput): Promise<Order> => {
+    async (
+      id: string,
+      updates: OrderWriteInput,
+      attemptPolicy: GraphQLAttemptPolicy = 'RETRY_TRANSIENT'
+    ): Promise<Order> => {
       const data = await executeGraphQL<{
         updateDeliveryJob: ApiOrder;
-      }>(graphQLOptions, UPDATE_ORDER_MUTATION, {
-        id,
-        input: {
-          status: updates.status ? toApiStatus(updates.status) : undefined,
-          priority: updates.priority ? toApiPriority(updates.priority) : undefined,
-          customerId: updates.customerId,
-          pickupAddress: updates.pickupAddress,
-          deliveryAddress: updates.deliveryAddress,
-          cargoItems: updates.items,
-          pricing: updates.pricing,
-          specialInstructions: updates.specialInstructions,
-          trackingNumber: updates.trackingNumber,
-          // `null` clears the booked slot; `undefined` leaves it untouched.
-          scheduledDelivery:
-            updates.scheduledDelivery === null ? null : updates.scheduledDelivery?.toISOString(),
-          vehicleId: updates.vehicleId,
-          driverId: updates.driverId,
-          routeId: updates.routeId,
+      }>(
+        graphQLOptions,
+        UPDATE_ORDER_MUTATION,
+        {
+          id,
+          input: {
+            status: updates.status ? toApiStatus(updates.status) : undefined,
+            priority: updates.priority ? toApiPriority(updates.priority) : undefined,
+            customerId: updates.customerId,
+            pickupAddress: updates.pickupAddress,
+            deliveryAddress: updates.deliveryAddress,
+            cargoItems: updates.items,
+            pricing: updates.pricing,
+            specialInstructions: updates.specialInstructions,
+            trackingNumber: updates.trackingNumber,
+            // `null` clears the booked slot; `undefined` leaves it untouched.
+            scheduledDelivery:
+              updates.scheduledDelivery === null ? null : updates.scheduledDelivery?.toISOString(),
+            vehicleId: updates.vehicleId,
+            driverId: updates.driverId,
+            routeId: updates.routeId,
+          },
         },
-      });
+        attemptPolicy,
+        attemptPolicy === 'SINGLE_ATTEMPT' ? 'updateDeliveryJob' : undefined
+      );
 
+      if (attemptPolicy === 'SINGLE_ATTEMPT')
+        assertOrderAcknowledgement(data.updateDeliveryJob, {
+          id,
+          vehicleId: updates.vehicleId,
+          driverId: updates.driverId,
+          status: updates.status ? toApiStatus(updates.status) : undefined,
+        });
       const updated = mapOrder(data.updateDeliveryJob);
       setOrders((previous) => previous.map((item) => (item.id === id ? updated : item)));
       return updated;
@@ -507,13 +529,20 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
     async (id: string, status: OrderStatus): Promise<Order> => {
       const data = await executeGraphQL<{
         updateDeliveryJobStatus: ApiOrder;
-      }>(graphQLOptions, UPDATE_ORDER_STATUS_MUTATION, {
-        id,
-        input: {
-          status: toApiStatus(status),
+      }>(
+        graphQLOptions,
+        UPDATE_ORDER_STATUS_MUTATION,
+        {
+          id,
+          input: {
+            status: toApiStatus(status),
+          },
         },
-      });
+        'SINGLE_ATTEMPT',
+        'updateDeliveryJobStatus'
+      );
 
+      assertOrderAcknowledgement(data.updateDeliveryJobStatus, { id, status: toApiStatus(status) });
       const updated = mapOrder(data.updateDeliveryJobStatus);
       setOrders((previous) => previous.map((item) => (item.id === id ? updated : item)));
       return updated;
@@ -567,6 +596,9 @@ export function useOrder(orderId: string | undefined) {
         deliveryJob: ApiOrder | null;
       }>(graphQLOptions, GET_ORDER_QUERY, { id: orderId });
 
+      if (data.deliveryJob && data.deliveryJob.id !== orderId) {
+        throw new Error('The requested order could not be verified.');
+      }
       setOrder(data.deliveryJob ? mapOrder(data.deliveryJob) : null);
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load order'));