@tokenoftrust/storefront-runner 2.4.51 → 2.4.53

package/apps/storefront/src/lib/admin/viewmodels/fulfillment.ts

@@ -1,49 +1,1175 @@
 /**
- * Fulfillment view model (baseline §Fulfillment) — operational shipment
- * queues, label locks, SLA age, and carrier/destination readiness. AI here is
- * intentionally narrow (`Fulfillment Assist` drafts only — see aiWorkflows.ts
- * / ai-evidence-substrate for the approval-gated substrate this later wires
- * into).
+ * Daily batch desk. Queues, evidence, and commands are a pure projection of the
+ * commerce contract. The test adapter is not a carrier and does not buy postage.
+ * Print payload and tracking links are owner-only. Public events and the desk
+ * log never carry a destination.
  */
+import {
+  actorMayCommand,
+  admitTrackingRead,
+  decideCommerceCommand,
+  paginateOrders,
+  publicCommerceEvent,
+  readOwnerAddress,
+  type CommerceActor,
+  type CommerceEvidence,
+  type CommerceStage,
+  type ComplianceState,
+  type FulfillmentState,
+  type LabelState,
+  type PaymentState,
+  type ProviderOutcome,
+  type PublicCommerceEvent,
+  type StockState,
+} from "../../../../../../packages/public-runtime/src/checkout-orders.js";
 
-export type FulfillmentQueueKey =
-  | "ready_to_ship"
-  | "holds"
-  | "picked"
-  | "packed"
-  | "label_needed"
-  | "shipped"
-  | "exceptions";
+export const SCRAPPY_FULFILLMENT_PATH = "/scrappy-fulfillment";
+export const WORKSPACE_PAGE_LIMIT = 4;
+export const TEST_ADAPTER_QUOTE_MINOR = 640;
+export const TRACKING_HOSTS = ["tracking.example"] as const;
 
-export interface FulfillmentQueueSummary {
-  key: FulfillmentQueueKey;
-  label: string;
-  count: number;
+export const WORKSPACE_QUEUES = ["ready", "held", "in_progress", "shipped"] as const;
+export type WorkspaceQueue = (typeof WORKSPACE_QUEUES)[number];
+export type WorkspaceQueueFilter = WorkspaceQueue | "all";
+
+export const WORKSPACE_EXCEPTIONS = [
+  "carrier-outage",
+  "refund-stop",
+  "unreadable-destination",
+  "other",
+] as const;
+export type WorkspaceException = (typeof WORKSPACE_EXCEPTIONS)[number];
+
+export const QUEUE_LABEL: Record<WorkspaceQueue, string> = {
+  ready: "Ready",
+  held: "Held",
+  in_progress: "In progress",
+  shipped: "Shipped",
+};
+
+const ACTOR_SPECS = [
+  { name: "owner", role: "owner" as const, sameTenant: true, sameStage: true },
+  { name: "caller", role: "caller" as const, sameTenant: true, sameStage: true },
+  { name: "denied", role: "denied" as const, sameTenant: true, sameStage: true },
+  { name: "other-tenant", role: "owner" as const, sameTenant: false, sameStage: true },
+  { name: "wrong-stage", role: "owner" as const, sameTenant: true, sameStage: false },
+];
+
+const FRESH: CommerceEvidence = {
+  verification: "fresh",
+  tax: "fresh",
+  risk: "fresh",
+  stock: "fresh",
+};
+
+const STALE: CommerceEvidence = {
+  verification: "UNKNOWN",
+  tax: "stale",
+  risk: "unreadable",
+  stock: "UNKNOWN",
+};
+
+const TOTALS = { subtotalMinor: 4000, shippingMinor: 0, taxMinor: 0, totalMinor: 4000 } as const;
+
+type PurchaseScript = "admit" | "pending" | "unknown";
+type VoidScript = "approved" | "pending" | "denied";
+type SignatureScript = "accept" | "refuse";
+
+export interface WorkspaceLine {
+  sku: string;
+  quantity: number;
+}
+
+interface WorkspaceOrder {
+  id: string;
+  placedAt: string;
+  lines: WorkspaceLine[];
+  currency: "USD";
+  payment: PaymentState;
+  compliance: ComplianceState;
+  stock: StockState;
+  fulfillment: FulfillmentState;
+  label: LabelState;
+  providerOutcome: ProviderOutcome | null;
+  evidence: CommerceEvidence;
+  picked: boolean;
+  packed: boolean;
+  manualException: WorkspaceException | null;
+  adultSignature: "required" | "accepted" | "refused";
+  purchaseKey: string | null;
+  purchaseId: string | null;
+  labelCostMinor: number | null;
+  trackingNumber: string | null;
+  trackingUrl: string | null;
+  ownerDestination: string;
+  purchaseScript: PurchaseScript;
+  voidScript: VoidScript;
+  signatureScript: SignatureScript;
+  slipIssued: boolean;
+  results: WorkspaceResult[];
 }
 
-export interface ShipmentRow {
+export interface WorkspaceResult {
   orderId: string;
-  queue: FulfillmentQueueKey;
-  carrier: string;
-  destination: string;
-  slaAgeHours: number;
-  labelLocked: boolean;
-  labelLockReason: string | null;
-  carrierReady: boolean;
-  destinationReady: boolean;
+  command: string;
+  status: "admitted" | "pending" | "unknown" | "refused";
+  reason: string;
+  livePurchase: false;
+  purchaseId: string | null;
+  costMinor: number | null;
+  releaseReservation: boolean;
+  restock: false;
 }
 
-export type FulfillmentAssistKind = "blocker_explanation" | "customer_update_draft" | "evidence_prep";
+export interface WorkspaceState {
+  tenantId: string;
+  stage: CommerceStage;
+  carrierAccountConfigured: boolean;
+  prohibitedCarriers: readonly ["USPS"];
+  adultSignatureRequired: true;
+  livePurchase: false;
+  currency: "USD";
+  quoteMinor: number;
+  orders: WorkspaceOrder[];
+  events: PublicCommerceEvent[];
+  log: string[];
+  lastResults: WorkspaceResult[];
+}
 
-export interface FulfillmentAssistDraft {
+export interface WorkspaceQuery {
+  actorName: string;
+  queue: WorkspaceQueueFilter;
+  q: string;
+  cursor: string | null;
+  limit: number;
+}
+
+export interface OwnerPrintPayload {
+  purchaseId: string;
+  format: "pdf";
+  adultSignature: "required";
+  livePurchase: false;
+  destination: string;
+}
+
+export interface PackingSlip {
   orderId: string;
-  kind: FulfillmentAssistKind;
-  summary: string;
+  lines: WorkspaceLine[];
+  wholeOrder: true;
+  destination: string | null;
+}
+
+export interface WorkspaceOrderView {
+  id: string;
+  placedAt: string;
+  lines: WorkspaceLine[];
+  unitCount: number;
+  currency: "USD";
+  payment: PaymentState;
+  stock: StockState;
+  fulfillment: FulfillmentState;
+  label: LabelState;
+  providerOutcome: ProviderOutcome | null;
+  evidence: CommerceEvidence;
+  picked: boolean;
+  packed: boolean;
+  manualException: WorkspaceException | null;
+  adultSignature: "required" | "accepted" | "refused";
+  purchaseKey: string | null;
+  purchaseId: string | null;
+  labelCostMinor: number | null;
+  trackingNumber: string | null;
+  trackingUrl: string | null;
+  queue: WorkspaceQueue;
+  holdReasons: string[];
+  results: WorkspaceResult[];
+  slip: PackingSlip | null;
+  printPayload: OwnerPrintPayload | null;
 }
 
 export interface FulfillmentViewModel {
   targetTenant: string;
-  queues: FulfillmentQueueSummary[];
-  shipments: ShipmentRow[];
-  assistDrafts: FulfillmentAssistDraft[];
+  stage: CommerceStage;
+  actorName: string;
+  actorRole: CommerceActor["role"];
+  livePurchase: false;
+  carrierAccountConfigured: boolean;
+  prohibitedCarriers: readonly ["USPS"];
+  adultSignatureRequired: true;
+  quoteMinor: number;
+  currency: "USD";
+  queue: WorkspaceQueueFilter;
+  q: string;
+  limit: number;
+  cursor: string | null;
+  nextCursor: string | null;
+  invalidCursor: boolean;
+  storewide: Record<WorkspaceQueue, number>;
+  filterCount: number;
+  pageCount: number;
+  orders: WorkspaceOrderView[];
+  pickList: Array<{ orderId: string; sku: string; quantity: number; packed: boolean }>;
+  events: PublicCommerceEvent[];
+  log: string[];
+  lastResults: WorkspaceResult[];
+}
+
+export interface WorkspaceCommand {
+  actorName: string;
+  command: string;
+  orderIds: string[];
+  purchaseKey: string | null;
+  carrier: string | null;
+  quantity: number | null;
+  quantityInvalid: boolean;
+  lineId: boolean;
+  exception: string | null;
+  accountConfigured: boolean | null;
+}
+
+export interface WorkspaceHttpRequest {
+  method: string;
+  url: string;
+  body: string | null;
+}
+
+export interface WorkspaceHttpResponse {
+  status: number;
+  contentType: string;
+  body: string;
+}
+
+export interface TestFulfillmentAdapter {
+  readonly livePurchase: false;
+  state(): WorkspaceState;
+  handle(request: WorkspaceHttpRequest): WorkspaceHttpResponse;
+}
+
+export function defaultWorkspaceQuery(): WorkspaceQuery {
+  return {
+    actorName: "owner",
+    queue: "ready",
+    q: "",
+    cursor: null,
+    limit: WORKSPACE_PAGE_LIMIT,
+  };
+}
+
+export function workspaceActor(tenantId: string, stage: CommerceStage, name: string): CommerceActor {
+  const known = ACTOR_SPECS.find((spec) => spec.name === name);
+  if (!known) return { role: "denied", tenantId, stage };
+  return {
+    role: known.role,
+    tenantId: known.sameTenant ? tenantId : `${tenantId}-b`,
+    stage: known.sameStage ? stage : stage === "preview" ? "publication" : "preview",
+  };
+}
+
+export function holdReasons(order: {
+  fulfillment: FulfillmentState;
+  manualException: WorkspaceException | null;
+  adultSignature: "required" | "accepted" | "refused";
+  evidence: CommerceEvidence;
+  payment: PaymentState;
+  stock: StockState;
+  label: LabelState;
+  providerOutcome: ProviderOutcome | null;
+}): string[] {
+  if (order.fulfillment === "handed_off") return [];
+  const reasons: string[] = [];
+  if (order.fulfillment === "cancelled") reasons.push("Cancelled. The shipment is the whole order.");
+  if (order.fulfillment === "held") reasons.push("Fulfillment is held.");
+  if (order.fulfillment === "UNKNOWN") reasons.push("Fulfillment is unknown. Reconcile before shipping.");
+  if (order.manualException) reasons.push(`Manual exception: ${order.manualException}.`);
+  if (order.adultSignature === "refused") reasons.push("Adult signature was refused. The order does not ship.");
+  const stale = (["verification", "tax", "risk", "stock"] as const).filter((key) => order.evidence[key] !== "fresh");
+  if (stale.length > 0) {
+    reasons.push(`Evidence is not fresh: ${stale.map((key) => `${key} ${order.evidence[key]}`).join(", ")}.`);
+  }
+  if (order.payment === "refund_requested" || order.payment === "refund_unknown") {
+    reasons.push("Refund stop. Reconcile the refund before shipping. Returns are not automated.");
+  } else if (order.payment === "capture_unknown") {
+    reasons.push("Capture is unknown. Reconcile before shipping.");
+  } else if (order.payment !== "captured") {
+    reasons.push("Payment is not captured.");
+  }
+  if (order.stock !== "confirmed") reasons.push("Stock is not confirmed.");
+  if (order.label === "UNKNOWN" || order.providerOutcome === "unknown") {
+    reasons.push("Label outcome is unknown. Do not buy another label.");
+  }
+  if (order.label === "intent" || order.providerOutcome === "intent") {
+    reasons.push("Label purchase is pending. Do not buy another label.");
+  }
+  if (order.label === "void_requested") reasons.push("Void is pending. Do not buy another label.");
+  return reasons;
+}
+
+export function workspaceQueue(order: {
+  fulfillment: FulfillmentState;
+  manualException: WorkspaceException | null;
+  adultSignature: "required" | "accepted" | "refused";
+  evidence: CommerceEvidence;
+  payment: PaymentState;
+  stock: StockState;
+  label: LabelState;
+  providerOutcome: ProviderOutcome | null;
+  picked: boolean;
+  packed: boolean;
+}): WorkspaceQueue {
+  if (order.fulfillment === "handed_off") return "shipped";
+  if (holdReasons(order).length > 0) return "held";
+  if (order.picked || order.packed || order.label === "purchased" || order.label === "printed") return "in_progress";
+  return "ready";
+}
+
+function unitCount(order: WorkspaceOrder): number {
+  return order.lines.reduce((sum, line) => sum + line.quantity, 0);
+}
+
+function blankResult(command: string, orderId: string, status: WorkspaceResult["status"], reason: string): WorkspaceResult {
+  return {
+    orderId,
+    command,
+    status,
+    reason,
+    livePurchase: false,
+    purchaseId: null,
+    costMinor: null,
+    releaseReservation: false,
+    restock: false,
+  };
+}
+
+export function initialWorkspaceState(tenantId: string, stage: CommerceStage = "preview"): WorkspaceState {
+  const shippable = {
+    payment: "captured" as const,
+    compliance: "fresh" as const,
+    stock: "confirmed" as const,
+    evidence: FRESH,
+    fulfillment: "ready" as const,
+  };
+  const order = (
+    id: string,
+    placedAt: string,
+    sku: string,
+    quantity: number,
+    extra: Partial<WorkspaceOrder> = {},
+  ): WorkspaceOrder => ({
+    id,
+    placedAt,
+    lines: [{ sku, quantity }],
+    currency: "USD",
+    payment: extra.payment ?? shippable.payment,
+    compliance: extra.compliance ?? shippable.compliance,
+    stock: extra.stock ?? shippable.stock,
+    fulfillment: extra.fulfillment ?? shippable.fulfillment,
+    label: extra.label ?? "none",
+    providerOutcome: extra.providerOutcome ?? null,
+    evidence: extra.evidence ?? shippable.evidence,
+    picked: extra.picked ?? false,
+    packed: extra.packed ?? false,
+    manualException: extra.manualException ?? null,
+    adultSignature: extra.adultSignature ?? "required",
+    purchaseKey: extra.purchaseKey ?? null,
+    purchaseId: extra.purchaseId ?? null,
+    labelCostMinor: extra.labelCostMinor ?? null,
+    trackingNumber: extra.trackingNumber ?? null,
+    trackingUrl: extra.trackingUrl ?? null,
+    ownerDestination: `dest-${id}`,
+    purchaseScript: extra.purchaseScript ?? "admit",
+    voidScript: extra.voidScript ?? "approved",
+    signatureScript: extra.signatureScript ?? "accept",
+    slipIssued: false,
+    results: [],
+  });
+
+  return {
+    tenantId,
+    stage,
+    carrierAccountConfigured: true,
+    prohibitedCarriers: ["USPS"],
+    adultSignatureRequired: true,
+    livePurchase: false,
+    currency: "USD",
+    quoteMinor: TEST_ADAPTER_QUOTE_MINOR,
+    orders: [
+      order("ord-ready-a", "2026-10-15T18:00:00.000Z", "sku-ready", 2),
+      order("ord-ready-b", "2026-10-15T17:00:00.000Z", "sku-ready", 1),
+      order("ord-ready-pending", "2026-10-15T16:00:00.000Z", "sku-ready", 1, { purchaseScript: "pending" }),
+      order("ord-ready-unknown", "2026-10-15T15:30:00.000Z", "sku-ready", 1, { purchaseScript: "unknown" }),
+      order("ord-ready-signature", "2026-10-15T15:00:00.000Z", "sku-ready", 1, { signatureScript: "refuse" }),
+      order("ord-packed", "2026-10-15T14:00:00.000Z", "sku-pack", 1, { picked: true, packed: true }),
+      order("ord-labeled", "2026-10-15T13:00:00.000Z", "sku-label", 1, {
+        picked: true,
+        packed: true,
+        label: "purchased",
+        providerOutcome: "accepted",
+        adultSignature: "accepted",
+        purchaseKey: "key-labeled",
+        purchaseId: "test-key-labeled",
+        labelCostMinor: TEST_ADAPTER_QUOTE_MINOR,
+      }),
+      order("ord-void-pending", "2026-10-15T12:40:00.000Z", "sku-void", 1, {
+        picked: true,
+        packed: true,
+        label: "purchased",
+        providerOutcome: "accepted",
+        adultSignature: "accepted",
+        purchaseKey: "key-void-pending",
+        purchaseId: "test-key-void-pending",
+        labelCostMinor: TEST_ADAPTER_QUOTE_MINOR,
+        voidScript: "pending",
+      }),
+      order("ord-void-denied", "2026-10-15T12:20:00.000Z", "sku-void", 1, {
+        picked: true,
+        packed: true,
+        label: "purchased",
+        providerOutcome: "accepted",
+        adultSignature: "accepted",
+        purchaseKey: "key-void-denied",
+        purchaseId: "test-key-void-denied",
+        labelCostMinor: TEST_ADAPTER_QUOTE_MINOR,
+        voidScript: "denied",
+      }),
+      order("ord-intent", "2026-10-15T12:00:00.000Z", "sku-intent", 1, {
+        label: "intent",
+        providerOutcome: "intent",
+        purchaseKey: "key-intent",
+      }),
+      order("ord-unknown-label", "2026-10-15T11:30:00.000Z", "sku-unknown", 1, {
+        label: "UNKNOWN",
+        providerOutcome: "unknown",
+        purchaseKey: "key-unknown",
+      }),
+      order("ord-evidence", "2026-10-15T11:00:00.000Z", "sku-evidence", 1, {
+        payment: "authorized",
+        compliance: "UNKNOWN",
+        stock: "reserved",
+        fulfillment: "held",
+        evidence: STALE,
+      }),
+      order("ord-refund", "2026-10-15T10:00:00.000Z", "sku-refund", 1, { payment: "refund_requested" }),
+      order("ord-refund-unknown", "2026-10-15T09:30:00.000Z", "sku-refund-unknown", 1, { payment: "refund_unknown" }),
+      order("ord-signature", "2026-10-15T09:00:00.000Z", "sku-signature", 1, {
+        adultSignature: "refused",
+        signatureScript: "refuse",
+      }),
+      order("ord-cancelled", "2026-10-15T08:30:00.000Z", "sku-cancelled", 1, { fulfillment: "cancelled" }),
+      order("ord-shipped", "2026-10-15T08:00:00.000Z", "sku-shipped", 1, {
+        picked: true,
+        packed: true,
+        fulfillment: "handed_off",
+        label: "printed",
+        providerOutcome: "accepted",
+        adultSignature: "accepted",
+        purchaseKey: "key-shipped",
+        purchaseId: "test-key-shipped",
+        labelCostMinor: TEST_ADAPTER_QUOTE_MINOR,
+        trackingNumber: "TRK-ord-shipped",
+        trackingUrl: "https://tracking.example/label/ord-shipped",
+      }),
+    ],
+    events: [],
+    log: [],
+    lastResults: [],
+  };
+}
+
+function matchesQuery(order: WorkspaceOrder, q: string): boolean {
+  if (q === "") return true;
+  const needle = q.toLowerCase();
+  if (order.id.toLowerCase().includes(needle)) return true;
+  return order.lines.some((line) => line.sku.toLowerCase().includes(needle));
+}
+
+function projectOrder(state: WorkspaceState, order: WorkspaceOrder, actor: CommerceActor): WorkspaceOrderView {
+  const scope = { tenantId: state.tenantId, stage: state.stage };
+  const queue = workspaceQueue(order);
+  let trackingUrl: string | null = null;
+  if (order.trackingUrl !== null) {
+    const admitted = admitTrackingRead({
+      actor,
+      resource: scope,
+      trackingUrl: order.trackingUrl,
+      allowedHosts: TRACKING_HOSTS,
+    });
+    if (admitted.ok) trackingUrl = order.trackingUrl;
+  }
+  const address = readOwnerAddress(actor, scope, () => order.ownerDestination);
+  const printPayload =
+    address.ok && order.purchaseId !== null && (order.label === "purchased" || order.label === "printed")
+      ? {
+          purchaseId: order.purchaseId,
+          format: "pdf" as const,
+          adultSignature: "required" as const,
+          livePurchase: false as const,
+          destination: address.address,
+        }
+      : null;
+  const slip: PackingSlip | null = order.slipIssued
+    ? {
+        orderId: order.id,
+        lines: order.lines.map((line) => ({ sku: line.sku, quantity: line.quantity })),
+        wholeOrder: true,
+        destination: address.ok ? address.address : null,
+      }
+    : null;
+  return {
+    id: order.id,
+    placedAt: order.placedAt,
+    lines: order.lines.map((line) => ({ sku: line.sku, quantity: line.quantity })),
+    unitCount: unitCount(order),
+    currency: "USD",
+    payment: order.payment,
+    stock: order.stock,
+    fulfillment: order.fulfillment,
+    label: order.label,
+    providerOutcome: order.providerOutcome,
+    evidence: { ...order.evidence },
+    picked: order.picked,
+    packed: order.packed,
+    manualException: order.manualException,
+    adultSignature: order.adultSignature,
+    purchaseKey: order.purchaseKey,
+    purchaseId: order.purchaseId,
+    labelCostMinor: order.labelCostMinor,
+    trackingNumber: order.trackingNumber,
+    trackingUrl,
+    queue,
+    holdReasons: holdReasons(order),
+    results: order.results.map((result) => ({ ...result })),
+    slip,
+    printPayload,
+  };
+}
+
+export function projectWorkspace(state: WorkspaceState, query: WorkspaceQuery): FulfillmentViewModel {
+  const actor = workspaceActor(state.tenantId, state.stage, query.actorName);
+  const storewide: Record<WorkspaceQueue, number> = { ready: 0, held: 0, in_progress: 0, shipped: 0 };
+  for (const order of state.orders) storewide[workspaceQueue(order)] += 1;
+  const filtered = state.orders.filter((order) => {
+    if (query.queue !== "all" && workspaceQueue(order) !== query.queue) return false;
+    return matchesQuery(order, query.q);
+  });
+  const page = paginateOrders(filtered, query.limit, query.cursor);
+  const pickList: FulfillmentViewModel["pickList"] = [];
+  for (const order of state.orders) {
+    if (!order.picked || order.fulfillment === "handed_off" || order.fulfillment === "cancelled") continue;
+    for (const line of order.lines) {
+      pickList.push({ orderId: order.id, sku: line.sku, quantity: line.quantity, packed: order.packed });
+    }
+  }
+  return {
+    targetTenant: state.tenantId,
+    stage: state.stage,
+    actorName: query.actorName,
+    actorRole: actor.role,
+    livePurchase: false,
+    carrierAccountConfigured: state.carrierAccountConfigured,
+    prohibitedCarriers: state.prohibitedCarriers,
+    adultSignatureRequired: true,
+    quoteMinor: state.quoteMinor,
+    currency: "USD",
+    queue: query.queue,
+    q: query.q,
+    limit: query.limit,
+    cursor: query.cursor,
+    nextCursor: page.nextCursor,
+    invalidCursor: page.invalidCursor,
+    storewide,
+    filterCount: filtered.length,
+    pageCount: page.orders.length,
+    orders: page.orders.map((order) => projectOrder(state, order, actor)),
+    pickList,
+    events: state.events.map((event) => ({ ...event, totals: { ...event.totals }, verificationDetail: { ...event.verificationDetail } })),
+    log: [...state.log],
+    lastResults: state.lastResults.map((result) => ({ ...result })),
+  };
+}
+
+function explicitCarrierReason(carrier: string | null): "usps-prohibited" | "carrier-not-selectable" | null {
+  if (carrier === null || carrier.trim() === "") return null;
+  if (carrier.trim().toUpperCase() === "USPS") return "usps-prohibited";
+  return "carrier-not-selectable";
+}
+
+function isException(value: string | null): value is WorkspaceException {
+  return WORKSPACE_EXCEPTIONS.some((item) => item === value);
+}
+
+function commerceStamp(order: WorkspaceOrder): string {
+  return [
+    order.payment,
+    order.compliance,
+    order.stock,
+    order.fulfillment,
+    order.label,
+    order.evidence.verification,
+    order.evidence.tax,
+    order.evidence.risk,
+    order.evidence.stock,
+  ].join("|");
+}
+
+function emitIfChanged(state: WorkspaceState, order: WorkspaceOrder, before: string): void {
+  if (commerceStamp(order) === before) return;
+  const eventVersion = state.events.filter((event) => event.orderId === order.id).length + 1;
+  state.events.push(
+    publicCommerceEvent({
+      eventVersion,
+      orderId: order.id,
+      placedAt: order.placedAt,
+      currency: order.currency,
+      payment: order.payment,
+      compliance: order.compliance,
+      stock: order.stock,
+      fulfillment: order.fulfillment,
+      label: order.label,
+      totals: TOTALS,
+      verificationDetail: order.evidence,
+    }),
+  );
+}
+
+function attemptKey(order: WorkspaceOrder, requested: string | null): string {
+  if (order.label === "voided") {
+    if (requested !== null && requested !== order.purchaseKey) return requested;
+    return `${order.purchaseKey ?? `pk-${order.id}`}-2`;
+  }
+  if (order.purchaseKey !== null) return order.purchaseKey;
+  if (requested !== null && requested.trim() !== "") return requested;
+  return `pk-${order.id}`;
+}
+
+function applyToOrder(state: WorkspaceState, order: WorkspaceOrder, command: WorkspaceCommand): WorkspaceResult {
+  const before = commerceStamp(order);
+  const finish = (result: WorkspaceResult): WorkspaceResult => {
+    order.results.push(result);
+    emitIfChanged(state, order, before);
+    return result;
+  };
+  const refuse = (reason: string, extra: Partial<WorkspaceResult> = {}): WorkspaceResult =>
+    finish({ ...blankResult(command.command, order.id, "refused", reason), purchaseId: order.purchaseId, ...extra, livePurchase: false, restock: false });
+
+  if (command.quantityInvalid) return refuse("quantity");
+  if (command.quantity !== null && command.quantity !== unitCount(order)) return refuse("partial-shipment");
+
+  if (command.command === "quote-label") {
+    const carrierReason = explicitCarrierReason(command.carrier);
+    if (carrierReason) return refuse(carrierReason);
+    if (!state.carrierAccountConfigured) return refuse("carrier-account");
+    return finish({
+      ...blankResult(command.command, order.id, "admitted", "quote"),
+      costMinor: state.quoteMinor,
+    });
+  }
+
+  if (command.command === "purchase-label") {
+    const carrierReason = explicitCarrierReason(command.carrier);
+    if (carrierReason) return refuse(carrierReason);
+    if (!state.carrierAccountConfigured) return refuse("carrier-account");
+    const decision = decideCommerceCommand({
+      command: "purchase-label",
+      payment: order.payment,
+      stock: order.stock,
+      fulfillment: order.fulfillment,
+      label: order.label,
+      evidence: order.evidence,
+      providerOutcome: order.providerOutcome,
+    });
+    if (!decision.admit) return refuse(decision.reason);
+    if (order.adultSignature === "refused" || order.signatureScript === "refuse") {
+      order.adultSignature = "refused";
+      return refuse("adult-signature");
+    }
+    const key = attemptKey(order, command.purchaseKey);
+    order.purchaseKey = key;
+    if (order.purchaseScript === "pending") {
+      order.label = "intent";
+      order.providerOutcome = "intent";
+      return finish({ ...blankResult(command.command, order.id, "pending", "pending"), purchaseId: null });
+    }
+    if (order.purchaseScript === "unknown") {
+      order.label = "UNKNOWN";
+      order.providerOutcome = "unknown";
+      return finish({ ...blankResult(command.command, order.id, "unknown", "unknown"), purchaseId: null });
+    }
+    order.label = "purchased";
+    order.providerOutcome = "accepted";
+    order.adultSignature = "accepted";
+    order.purchaseId = `test-${key}`;
+    order.labelCostMinor = state.quoteMinor;
+    return finish({
+      ...blankResult(command.command, order.id, "admitted", "purchased"),
+      purchaseId: order.purchaseId,
+      costMinor: state.quoteMinor,
+    });
+  }
+
+  if (command.command === "print-label" || command.command === "reprint-label") {
+    const decision = decideCommerceCommand({
+      command: "print-label",
+      payment: order.payment,
+      stock: order.stock,
+      fulfillment: order.fulfillment,
+      label: order.label,
+      evidence: order.evidence,
+      providerOutcome: order.providerOutcome,
+    });
+    if (!decision.admit) return refuse(decision.reason);
+    const reason = command.command === "reprint-label" || order.label === "printed" ? "reprint" : "printed";
+    order.label = "printed";
+    return finish({ ...blankResult(command.command, order.id, "admitted", reason), purchaseId: order.purchaseId });
+  }
+
+  if (command.command === "void-label") {
+    if (order.fulfillment === "handed_off") return refuse("fulfillment");
+    if (
+      order.label === "UNKNOWN" ||
+      order.label === "intent" ||
+      order.label === "void_requested" ||
+      order.providerOutcome === "unknown" ||
+      order.providerOutcome === "intent"
+    ) {
+      return refuse("reconcile");
+    }
+    if (order.label !== "purchased" && order.label !== "printed") return refuse("label");
+    if (order.voidScript === "pending") {
+      order.label = "void_requested";
+      return finish({ ...blankResult(command.command, order.id, "pending", "void-pending"), purchaseId: order.purchaseId });
+    }
+    if (order.voidScript === "denied") return refuse("void-denied");
+    order.label = "voided";
+    order.providerOutcome = "voided";
+    return finish({ ...blankResult(command.command, order.id, "admitted", "voided"), purchaseId: order.purchaseId });
+  }
+
+  if (command.command === "hand-off") {
+    if (!order.packed) return refuse("not-packed");
+    if (order.adultSignature !== "accepted") return refuse("adult-signature");
+    const decision = decideCommerceCommand({
+      command: "hand-off",
+      payment: order.payment,
+      stock: order.stock,
+      fulfillment: order.fulfillment,
+      label: order.label,
+      evidence: order.evidence,
+      providerOutcome: order.providerOutcome,
+    });
+    if (!decision.admit) return refuse(decision.reason);
+    order.fulfillment = "handed_off";
+    order.trackingNumber = `TRK-${order.id}`;
+    order.trackingUrl = `https://tracking.example/label/${encodeURIComponent(order.id)}`;
+    return finish({ ...blankResult(command.command, order.id, "admitted", "handed-off"), purchaseId: order.purchaseId });
+  }
+
+  if (command.command === "cancel") {
+    const decision = decideCommerceCommand({
+      command: "cancel",
+      payment: order.payment,
+      stock: order.stock,
+      fulfillment: order.fulfillment,
+      label: order.label,
+      evidence: order.evidence,
+      providerOutcome: order.providerOutcome,
+    });
+    if (!decision.admit) return refuse(decision.reason);
+    order.fulfillment = "cancelled";
+    return finish({
+      ...blankResult(command.command, order.id, "admitted", "cancelled"),
+      purchaseId: order.purchaseId,
+      releaseReservation: decision.releaseReservation,
+    });
+  }
+
+  if (command.command === "pick-batch") {
+    if (workspaceQueue(order) !== "ready") return refuse("not-ready");
+    order.picked = true;
+    return finish(blankResult(command.command, order.id, "admitted", "picked"));
+  }
+
+  if (command.command === "confirm-pack") {
+    if (order.fulfillment === "handed_off" || order.fulfillment === "cancelled") return refuse("fulfillment");
+    if (holdReasons(order).length > 0) return refuse("held");
+    if (!order.picked) return refuse("not-picked");
+    if (order.packed) return refuse("already-packed");
+    order.packed = true;
+    return finish(blankResult(command.command, order.id, "admitted", "packed"));
+  }
+
+  if (command.command === "packing-slip") {
+    if (order.fulfillment === "cancelled") return refuse("fulfillment");
+    order.slipIssued = true;
+    return finish(blankResult(command.command, order.id, "admitted", "packing-slip"));
+  }
+
+  if (command.command === "record-exception") {
+    if (order.fulfillment === "handed_off") return refuse("fulfillment");
+    if (!isException(command.exception)) return refuse("exception");
+    order.manualException = command.exception;
+    return finish(blankResult(command.command, order.id, "admitted", command.exception));
+  }
+
+  if (command.command === "refund" || command.command === "return") return refuse("returns-not-automated");
+  return refuse("unknown-command");
+}
+
+function finishCommand(state: WorkspaceState, actorName: string, results: WorkspaceResult[]): WorkspaceState {
+  state.lastResults = results;
+  for (const result of results) {
+    state.log.push(`${actorName} ${result.command} ${result.orderId} ${result.status} ${result.reason}`);
+  }
+  return state;
+}
+
+export function applyWorkspaceCommand(input: WorkspaceState, command: WorkspaceCommand): WorkspaceState {
+  const state = structuredClone(input);
+  const actor = workspaceActor(state.tenantId, state.stage, command.actorName);
+  const scope = { tenantId: state.tenantId, stage: state.stage };
+  if (!actorMayCommand(actor, scope)) {
+    const ids = command.orderIds.length > 0 ? command.orderIds : [""];
+    return finishCommand(
+      state,
+      command.actorName,
+      ids.map((orderId) => blankResult(command.command, orderId, "refused", "denied")),
+    );
+  }
+  if (command.lineId) {
+    const ids = command.orderIds.length > 0 ? command.orderIds : [""];
+    return finishCommand(
+      state,
+      command.actorName,
+      ids.map((orderId) => blankResult(command.command, orderId, "refused", "partial-shipment")),
+    );
+  }
+  if (command.command === "set-carrier-account") {
+    const carrierReason = explicitCarrierReason(command.carrier);
+    if (carrierReason) return finishCommand(state, command.actorName, [blankResult(command.command, "", "refused", carrierReason)]);
+    if (command.accountConfigured === null) {
+      return finishCommand(state, command.actorName, [blankResult(command.command, "", "refused", "carrier-account")]);
+    }
+    state.carrierAccountConfigured = command.accountConfigured;
+    return finishCommand(state, command.actorName, [
+      blankResult(command.command, "", "admitted", command.accountConfigured ? "configured" : "missing"),
+    ]);
+  }
+  if (command.orderIds.length === 0) {
+    return finishCommand(state, command.actorName, [blankResult(command.command, "", "refused", "empty-batch")]);
+  }
+  const results: WorkspaceResult[] = [];
+  const seen = new Set<string>();
+  for (const orderId of command.orderIds) {
+    if (seen.has(orderId)) continue;
+    seen.add(orderId);
+    const order = state.orders.find((item) => item.id === orderId);
+    if (order === undefined) {
+      results.push(blankResult(command.command, orderId, "refused", "missing"));
+      continue;
+    }
+    results.push(applyToOrder(state, order, command));
+  }
+  return finishCommand(state, command.actorName, results);
+}
+
+const COMMANDS = new Set([
+  "quote-label",
+  "purchase-label",
+  "print-label",
+  "reprint-label",
+  "void-label",
+  "hand-off",
+  "cancel",
+  "confirm-pack",
+  "pick-batch",
+  "packing-slip",
+  "record-exception",
+  "set-carrier-account",
+  "refund",
+  "return",
+]);
+
+export function parseWorkspaceQuery(params: URLSearchParams): WorkspaceQuery {
+  const queueRaw = params.get("queue");
+  const queue: WorkspaceQueueFilter =
+    queueRaw === "all" || queueRaw === "ready" || queueRaw === "held" || queueRaw === "in_progress" || queueRaw === "shipped"
+      ? queueRaw
+      : "ready";
+  const limitRaw = params.get("limit");
+  let limit = WORKSPACE_PAGE_LIMIT;
+  if (limitRaw !== null && /^\d+$/.test(limitRaw)) {
+    const parsed = Number(limitRaw);
+    if (parsed >= 1 && parsed <= 50) limit = parsed;
+  }
+  const cursorRaw = params.get("cursor");
+  return {
+    actorName: (params.get("actor") ?? "owner").trim() || "owner",
+    queue,
+    q: (params.get("q") ?? "").trim(),
+    cursor: cursorRaw !== null && cursorRaw.trim() !== "" ? cursorRaw : null,
+    limit,
+  };
+}
+
+export function parseWorkspaceCommand(params: URLSearchParams): { ok: true; command: WorkspaceCommand } | { ok: false; error: string } {
+  const command = (params.get("command") ?? "").trim();
+  if (!COMMANDS.has(command)) return { ok: false, error: "unknown-command" };
+  let quantity: number | null = null;
+  let quantityInvalid = false;
+  if (params.has("quantity")) {
+    const raw = (params.get("quantity") ?? "").trim();
+    if (raw !== "") {
+      if (!/^\d+$/.test(raw)) quantityInvalid = true;
+      else quantity = Number(raw);
+    }
+  }
+  const configuredRaw = params.get("configured");
+  const accountConfigured = configuredRaw === "1" ? true : configuredRaw === "0" ? false : null;
+  const carrierRaw = params.get("carrier");
+  const purchaseRaw = params.get("purchaseKey");
+  return {
+    ok: true,
+    command: {
+      actorName: (params.get("actor") ?? "owner").trim() || "owner",
+      command,
+      orderIds: params.getAll("orderId").map((id) => id.trim()).filter((id) => id !== ""),
+      purchaseKey: purchaseRaw !== null && purchaseRaw.trim() !== "" ? purchaseRaw.trim() : null,
+      carrier: carrierRaw !== null && carrierRaw.trim() !== "" ? carrierRaw : null,
+      quantity,
+      quantityInvalid,
+      lineId: params.has("lineId"),
+      exception: params.get("exception"),
+      accountConfigured,
+    },
+  };
+}
+
+export function handleWorkspaceRequest(
+  state: WorkspaceState,
+  request: WorkspaceHttpRequest,
+): { state: WorkspaceState; response: WorkspaceHttpResponse } {
+  let url: URL;
+  try {
+    url = new URL(request.url, "http://127.0.0.1");
+  } catch {
+    return { state, response: { status: 400, contentType: "text/plain; charset=utf-8", body: "bad url" } };
+  }
+  if (url.pathname !== SCRAPPY_FULFILLMENT_PATH) {
+    return { state, response: { status: 404, contentType: "text/plain; charset=utf-8", body: "not found" } };
+  }
+  const method = request.method.toUpperCase();
+  if (method === "GET") {
+    const view = projectWorkspace(state, parseWorkspaceQuery(url.searchParams));
+    return {
+      state,
+      response: { status: 200, contentType: "text/html; charset=utf-8", body: renderFulfillmentDocument(view) },
+    };
+  }
+  if (method === "POST") {
+    const params = new URLSearchParams(request.body ?? "");
+    const parsed = parseWorkspaceCommand(params);
+    if (!parsed.ok) {
+      return {
+        state,
+        response: {
+          status: 400,
+          contentType: "text/html; charset=utf-8",
+          body: `<!doctype html><p data-command-error="${esc(parsed.error)}">Unknown command.</p>`,
+        },
+      };
+    }
+    const next = applyWorkspaceCommand(state, parsed.command);
+    const query = parseWorkspaceQuery(params);
+    query.cursor = null;
+    const view = projectWorkspace(next, query);
+    return {
+      state: next,
+      response: { status: 200, contentType: "text/html; charset=utf-8", body: renderFulfillmentDocument(view) },
+    };
+  }
+  return { state, response: { status: 405, contentType: "text/plain; charset=utf-8", body: "method" } };
+}
+
+export function createTestFulfillmentAdapter(tenantId = "synthetic-tenant", stage: CommerceStage = "preview"): TestFulfillmentAdapter {
+  let state = initialWorkspaceState(tenantId, stage);
+  return {
+    livePurchase: false,
+    state: () => state,
+    handle(request) {
+      const outcome = handleWorkspaceRequest(state, request);
+      state = outcome.state;
+      return outcome.response;
+    },
+  };
+}
+
+function esc(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function href(view: FulfillmentViewModel, over: Partial<WorkspaceQuery> = {}): string {
+  const next: WorkspaceQuery = {
+    actorName: over.actorName ?? view.actorName,
+    queue: over.queue ?? view.queue,
+    q: over.q ?? view.q,
+    limit: over.limit ?? view.limit,
+    cursor: "cursor" in over ? (over.cursor ?? null) : view.cursor,
+  };
+  const params = new URLSearchParams();
+  params.set("actor", next.actorName);
+  params.set("queue", next.queue);
+  params.set("limit", String(next.limit));
+  if (next.q !== "") params.set("q", next.q);
+  if (next.cursor !== null) params.set("cursor", next.cursor);
+  return `${SCRAPPY_FULFILLMENT_PATH}?${params.toString()}`;
+}
+
+function hiddenFields(view: FulfillmentViewModel, command: string, extras: Array<[string, string]> = []): string {
+  const fields: Array<[string, string]> = [
+    ["actor", view.actorName],
+    ["queue", view.queue],
+    ["q", view.q],
+    ["limit", String(view.limit)],
+    ["command", command],
+    ...extras,
+  ];
+  return fields
+    .map(([name, value]) => `<input type="hidden" name="${esc(name)}" value="${esc(value)}">`)
+    .join("");
+}
+
+function resultItem(result: WorkspaceResult): string {
+  return `<li data-result-order="${esc(result.orderId)}" data-result-command="${esc(result.command)}" data-result-status="${result.status}" data-result-reason="${esc(result.reason)}" data-cost-minor="${result.costMinor ?? ""}" data-purchase-id="${esc(result.purchaseId ?? "")}" data-live-purchase="false" data-release-reservation="${result.releaseReservation ? "true" : "false"}" data-restock="false" data-blind-repurchase="false">${esc(result.command)} ${esc(result.orderId)} ${result.status} ${esc(result.reason)}</li>`;
+}
+
+function orderActions(view: FulfillmentViewModel, order: WorkspaceOrderView, action: string): string {
+  const purchaseExtras: Array<[string, string]> = [["orderId", order.id]];
+  if (order.purchaseKey !== null) purchaseExtras.push(["purchaseKey", order.purchaseKey]);
+  const one = (command: string, label: string, extras: Array<[string, string]> = [["orderId", order.id]]) =>
+    `<form method="post" action="${action}">${hiddenFields(view, command, extras)}<button type="submit">${esc(label)}</button></form>`;
+  const exceptionOptions = WORKSPACE_EXCEPTIONS.map(
+    (reason) => `<option value="${reason}">${esc(reason)}</option>`,
+  ).join("");
+  return `<div data-order-actions="${esc(order.id)}">
+    ${one("quote-label", "Quote cost")}
+    ${one("purchase-label", "Purchase label", purchaseExtras)}
+    ${one("print-label", "Print label")}
+    ${one("reprint-label", "Reprint label")}
+    ${one("void-label", "Void label")}
+    ${one("hand-off", "Hand off")}
+    ${one("confirm-pack", "Confirm pack")}
+    ${one("packing-slip", "Packing slip")}
+    ${one("cancel", "Cancel order")}
+    <form method="post" action="${action}">${hiddenFields(view, "record-exception", [["orderId", order.id]])}<label>Manual exception <select name="exception">${exceptionOptions}</select></label><button type="submit">Record manual exception</button></form>
+  </div>`;
+}
+
+export function renderFulfillmentWorkspace(view: FulfillmentViewModel): string {
+  const queueLinks = (["ready", "held", "in_progress", "shipped", "all"] as const)
+    .map((queue) => {
+      const count = queue === "all" ? "" : ` (${view.storewide[queue]})`;
+      const label = queue === "all" ? "All" : QUEUE_LABEL[queue];
+      return `<a data-queue-link="${queue}" href="${esc(href(view, { queue, cursor: null }))}">${esc(label)}${count}</a>`;
+    })
+    .join("");
+  const actorLinks = ACTOR_SPECS.map(
+    (spec) =>
+      `<a data-actor-link="${spec.name}" href="${esc(href(view, { actorName: spec.name, cursor: null }))}">${esc(spec.name)}</a>`,
+  ).join("");
+  const action = esc(href(view, { cursor: null }));
+  const rows = view.orders
+    .map((order) => {
+      const pick = order.queue === "ready"
+        ? `<input form="scrappy-pick" type="checkbox" name="orderId" value="${esc(order.id)}" data-pick-box="${esc(order.id)}">`
+        : "";
+      const evidence = `verification ${order.evidence.verification}, tax ${order.evidence.tax}, risk ${order.evidence.risk}, stock ${order.evidence.stock}`;
+      return `<tr data-order-row="${esc(order.id)}" data-queue="${order.queue}" data-label="${esc(order.label)}" data-payment="${esc(order.payment)}" data-fulfillment="${esc(order.fulfillment)}" data-packed="${order.packed ? "true" : "false"}" data-picked="${order.picked ? "true" : "false"}" data-adult-signature="${order.adultSignature}" data-purchase-id="${esc(order.purchaseId ?? "")}" data-purchase-key="${esc(order.purchaseKey ?? "")}" data-whole-order="true">
+        <td>${pick}</td>
+        <td>${esc(order.id)}</td>
+        <td>${esc(QUEUE_LABEL[order.queue])}</td>
+        <td>${order.lines.map((line) => `${esc(line.sku)} × ${line.quantity}`).join(", ")}</td>
+        <td>${esc(order.label)}</td>
+        <td>${esc(evidence)}</td>
+        <td data-hold="${esc(order.holdReasons.join(" "))}">${order.holdReasons.length === 0 ? "None" : esc(order.holdReasons.join(" "))}</td>
+        <td>${esc(order.trackingNumber ?? "")}</td>
+      </tr>`;
+    })
+    .join("");
+  const details = view.orders
+    .map((order) => {
+      const payload = order.printPayload
+        ? `<pre data-print-payload data-order-id="${esc(order.id)}">${esc(JSON.stringify(order.printPayload))}</pre>`
+        : order.label === "purchased" || order.label === "printed"
+          ? `<p data-print-denied="owner-only" data-order-id="${esc(order.id)}">Print payload is owner-only.</p>`
+          : "";
+      const slip = order.slip
+        ? `<div data-packing-slip data-order-id="${esc(order.id)}" data-whole-order="true"><ul>${order.slip.lines
+            .map((line) => `<li data-slip-sku="${esc(line.sku)}" data-slip-quantity="${line.quantity}">${esc(line.sku)} ${line.quantity}</li>`)
+            .join("")}</ul>${
+            order.slip.destination
+              ? `<p data-slip-destination>${esc(order.slip.destination)}</p>`
+              : `<p data-slip-destination-denied="owner-only">Destination is owner-only.</p>`
+          }</div>`
+        : "";
+      const tracking = order.trackingNumber
+        ? `<p data-tracking-number data-order-id="${esc(order.id)}">${esc(order.trackingNumber)}</p>${
+            order.trackingUrl
+              ? `<a data-tracking-url data-order-id="${esc(order.id)}" href="${esc(order.trackingUrl)}" referrerpolicy="no-referrer">Tracking</a>`
+              : `<p data-tracking-denied="owner-only" data-order-id="${esc(order.id)}">Tracking link is owner-only.</p>`
+          }`
+        : "";
+      return `<section data-order-detail="${esc(order.id)}">${payload}${slip}${tracking}${orderActions(view, order, action)}</section>`;
+    })
+    .join("");
+  const pickItems = view.pickList
+    .map(
+      (line) =>
+        `<li data-pick-order="${esc(line.orderId)}" data-sku="${esc(line.sku)}" data-quantity="${line.quantity}" data-packed="${line.packed ? "true" : "false"}">${esc(line.orderId)} ${esc(line.sku)} ${line.quantity}</li>`,
+    )
+    .join("");
+  const next = view.nextCursor
+    ? `<a data-page-next href="${esc(href(view, { cursor: view.nextCursor }))}">Next page</a>`
+    : "";
+  const account = view.carrierAccountConfigured ? "configured" : "missing";
+  return `<div data-scrappy-batch data-target-tenant="${esc(view.targetTenant)}" data-test-adapter="1" data-live-purchase="false" data-carrier-account="${account}" data-prohibited-carrier="USPS" data-adult-signature-required="true" data-partial-shipment="unavailable" data-returns="unavailable" data-blind-repurchase="false" data-actor="${esc(view.actorName)}" data-actor-role="${esc(view.actorRole)}" data-storewide-ready="${view.storewide.ready}" data-storewide-held="${view.storewide.held}" data-storewide-in-progress="${view.storewide.in_progress}" data-storewide-shipped="${view.storewide.shipped}" data-filter-count="${view.filterCount}" data-page-count="${view.pageCount}" data-queue="${esc(view.queue)}">
+    <h2 id="fulfillment-title">Daily batch</h2>
+    <p>This desk reads the test adapter. Not a live label purchase. Carrier account is configuration. USPS is prohibited. Adult signature is required. Shipment is the whole order. Partial shipment is not available. Returns are not automated.</p>
+    <p data-carrier-account-text>${view.carrierAccountConfigured ? "Carrier account: configured." : "Carrier account: not configured. Do not choose a carrier."}</p>
+    <p><a data-refresh href="${esc(href(view))}">Refresh</a></p>
+    <nav data-actor-switch>${actorLinks}</nav>
+    <nav data-queue-switch>${queueLinks}</nav>
+    <form method="get" action="${SCRAPPY_FULFILLMENT_PATH}">
+      <input type="hidden" name="actor" value="${esc(view.actorName)}">
+      <input type="hidden" name="limit" value="${view.limit}">
+      <label>Queue <select name="queue">
+        <option value="ready"${view.queue === "ready" ? " selected" : ""}>Ready</option>
+        <option value="held"${view.queue === "held" ? " selected" : ""}>Held</option>
+        <option value="in_progress"${view.queue === "in_progress" ? " selected" : ""}>In progress</option>
+        <option value="shipped"${view.queue === "shipped" ? " selected" : ""}>Shipped</option>
+        <option value="all"${view.queue === "all" ? " selected" : ""}>All</option>
+      </select></label>
+      <label>Filter <input name="q" value="${esc(view.q)}"></label>
+      <button type="submit">Apply filter</button>
+    </form>
+    <p data-counts>Storewide ready ${view.storewide.ready}. Held ${view.storewide.held}. In progress ${view.storewide.in_progress}. Shipped ${view.storewide.shipped}. Filter ${view.filterCount}. This page ${view.pageCount}.</p>
+    ${view.invalidCursor ? `<p data-invalid-cursor="1">Unknown page cursor. No rows on this page.</p>` : ""}
+    <form id="scrappy-pick" method="post" action="${action}">${hiddenFields(view, "pick-batch")}<button type="submit">Build pick list</button></form>
+    <table>
+      <thead><tr><th>Pick</th><th>Order</th><th>Queue</th><th>Lines</th><th>Label</th><th>Evidence</th><th>Hold</th><th>Tracking number</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+    ${next}
+    <section data-pick-list><h3>Pick list</h3><ul>${pickItems}</ul></section>
+    ${details}
+    <ol data-last-results>${view.lastResults.map(resultItem).join("")}</ol>
+    <section data-public-events>${view.events.map((event) => `<pre>${esc(JSON.stringify(event))}</pre>`).join("")}</section>
+    <pre data-adapter-log>${esc(view.log.join("\n"))}</pre>
+  </div>`;
+}
+
+export function renderFulfillmentDocument(view: FulfillmentViewModel): string {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Daily batch</title></head><body><section id="fulfillment" data-admin-panel data-agent-scope="fulfillment">${renderFulfillmentWorkspace(view)}</section></body></html>`;
 }