@open-mercato/core 0.10.1-develop.7709.1.046124599c → 0.10.1-develop.7714.1.9dbb8200d8

package/src/modules/wms/components/backend/asnCompleteOptimisticLock.ts

@@ -0,0 +1,52 @@
+import { extractOptimisticLockConflict } from '@open-mercato/ui/backend/utils/optimisticLock'
+
+/**
+ * Apply a 409 optimistic-lock `currentUpdatedAt` into a mutable token holder so
+ * ASN complete retries send a fresh If-Match.
+ * Returns the refreshed token, or null when the response is not a lock conflict.
+ */
+export function applyAsnCompleteLockTokenFromConflict(
+  tokenHolder: { current: string | null },
+  response: { status: number; body: unknown },
+): string | null {
+  const conflict = extractOptimisticLockConflict({
+    status: response.status,
+    body: response.body,
+  })
+  if (!conflict?.currentUpdatedAt) return null
+  tokenHolder.current = conflict.currentUpdatedAt
+  return conflict.currentUpdatedAt
+}
+
+/**
+ * Prefer a mutable ASN lock ref (updated on receive success) over the async
+ * query `updated_at`, so a second receive before header refetch does not send
+ * a stale If-Match.
+ */
+export function resolveAsnReceiveLockToken(
+  tokenHolder: { current: string | null },
+  asnUpdatedAt?: string | null,
+): string | null {
+  if (typeof tokenHolder.current === 'string' && tokenHolder.current.trim()) {
+    return tokenHolder.current.trim()
+  }
+  if (typeof asnUpdatedAt === 'string' && asnUpdatedAt.trim()) {
+    return asnUpdatedAt.trim()
+  }
+  return asnUpdatedAt ?? null
+}
+
+/**
+ * Store ASN `updated_at` from a successful receive so the next openReceive /
+ * query-cache seed uses a fresh If-Match without waiting on refetch.
+ */
+export function applyAsnReceiveLockTokenFromSuccess(
+  tokenHolder: { current: string | null },
+  asnUpdatedAt?: string | null,
+): string | null {
+  if (typeof asnUpdatedAt !== 'string') return null
+  const trimmed = asnUpdatedAt.trim()
+  if (!trimmed) return null
+  tokenHolder.current = trimmed
+  return trimmed
+}

package/src/modules/wms/components/backend/asnReceivingLinesLoader.ts

@@ -0,0 +1,83 @@
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+
+/** API max pageSize (AGENTS.md); ASN detail loops until short page. */
+export const ASN_RECEIVING_LINES_PAGE_SIZE = 100
+
+export type AsnReceivingLineRow = {
+  id: string
+  asn_id?: string | null
+  catalog_variant_id?: string | null
+  expected_qty?: string | number | null
+  received_qty?: string | number | null
+  lot_number?: string | null
+  serial_numbers?: string[] | null
+  qc_status?: string | null
+  target_staging_location_id?: string | null
+  rejection_reason?: string | null
+  updated_at?: string | null
+}
+
+type PagedResponse<T> = {
+  items: T[]
+  total: number
+  totalPages: number
+}
+
+export type LoadAllAsnReceivingLinesResult =
+  | { ok: true; items: AsnReceivingLineRow[] }
+  | { ok: false; response: Response }
+
+type FetchPage = (
+  page: number,
+  pageSize: number,
+) => Promise<{
+  ok: boolean
+  response: Response
+  result?: PagedResponse<AsnReceivingLineRow> | null
+}>
+
+/**
+ * Load every receiving line for an ASN detail console.
+ * Short-page termination only — never use `totalPages` (OM_LIST_COUNT_CAP).
+ */
+export async function loadAllAsnReceivingLines(
+  asnId: string,
+  options?: {
+    pageSize?: number
+    fetchPage?: FetchPage
+  },
+): Promise<LoadAllAsnReceivingLinesResult> {
+  const pageSize = Math.min(
+    Math.max(1, options?.pageSize ?? ASN_RECEIVING_LINES_PAGE_SIZE),
+    ASN_RECEIVING_LINES_PAGE_SIZE,
+  )
+  const fetchPage: FetchPage =
+    options?.fetchPage ??
+    (async (page, size) => {
+      const call = await apiCall<PagedResponse<AsnReceivingLineRow>>(
+        `/api/wms/receiving-lines?asnId=${encodeURIComponent(asnId)}&page=${page}&pageSize=${size}`,
+      )
+      return {
+        ok: call.ok,
+        response: call.response,
+        result: call.result ?? null,
+      }
+    })
+
+  const items: AsnReceivingLineRow[] = []
+  let page = 1
+  // Short-page termination: `totalPages` derives from `total`, which is a
+  // display value that can be capped (OM_LIST_COUNT_CAP) — never a loop bound.
+  for (;;) {
+    const call = await fetchPage(page, pageSize)
+    if (!call.ok) {
+      return { ok: false, response: call.response }
+    }
+    const batch = call.result?.items ?? []
+    items.push(...batch)
+    if (batch.length < pageSize) break
+    page += 1
+  }
+
+  return { ok: true, items }
+}

package/src/modules/wms/components/backend/inboundStatusUi.ts

@@ -0,0 +1,154 @@
+import type { StatusBadgeVariant } from '@open-mercato/ui/primitives/status-badge'
+import { hasAsnReceiptActivity, isAsnCloseable } from '../../lib/asnReceiving'
+
+export type AsnStatus = 'draft' | 'in_transit' | 'received' | 'closed'
+export type ReceivingLineQcStatus = 'pending' | 'passed' | 'failed'
+export type PutawayTaskStatus = 'open' | 'in_progress' | 'done' | 'cancelled'
+
+export type AsnCompleteGateLine = {
+  expected_qty?: string | number | null
+  received_qty?: string | number | null
+  qc_status?: string | null
+}
+
+export function asnStatusVariant(status: string | null | undefined): StatusBadgeVariant {
+  switch (status) {
+    case 'in_transit':
+      return 'info'
+    case 'received':
+      return 'success'
+    case 'closed':
+      return 'neutral'
+    case 'draft':
+    default:
+      return 'neutral'
+  }
+}
+
+export function qcStatusVariant(status: string | null | undefined): StatusBadgeVariant {
+  switch (status) {
+    case 'passed':
+      return 'success'
+    case 'failed':
+      return 'error'
+    case 'pending':
+    default:
+      return 'warning'
+  }
+}
+
+export function putawayStatusVariant(status: string | null | undefined): StatusBadgeVariant {
+  switch (status) {
+    case 'in_progress':
+      return 'warning'
+    case 'done':
+      return 'success'
+    case 'cancelled':
+      return 'neutral'
+    case 'open':
+    default:
+      return 'info'
+  }
+}
+
+export function formatAgingLabel(createdAt: string | null | undefined, nowMs = Date.now()): string | null {
+  if (!createdAt) return null
+  const createdMs = new Date(createdAt).getTime()
+  if (Number.isNaN(createdMs)) return null
+  const minutes = Math.max(0, Math.floor((nowMs - createdMs) / 60_000))
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 48) return `${hours}h`
+  const days = Math.floor(hours / 24)
+  return `${days}d`
+}
+
+/** Map putaway queue column ids to list API `sortField` values. Aging is derived from created_at. */
+export function mapPutawayQueueSortField(columnId: string): string {
+  return columnId === 'aging' ? 'createdAt' : columnId
+}
+
+/**
+ * Map UI sort direction to list API `sortDir`.
+ * Aging is age-since-created: UI "desc" (oldest first) is createdAt ascending,
+ * and UI "asc" (newest first) is createdAt descending.
+ */
+export function mapPutawayQueueSortDir(columnId: string, desc: boolean): 'asc' | 'desc' {
+  const dir = desc ? 'desc' : 'asc'
+  if (columnId === 'aging') {
+    return desc ? 'asc' : 'desc'
+  }
+  return dir
+}
+
+export function lineHasDiscrepancy(
+  expectedQty: string | number | null | undefined,
+  receivedQty: string | number | null | undefined,
+): boolean {
+  const expected = Number(expectedQty ?? 0)
+  const received = Number(receivedQty ?? 0)
+  if (!Number.isFinite(expected) || !Number.isFinite(received)) return false
+  return received !== expected && received > 0
+}
+
+/**
+ * UI visibility for putaway Complete (and scan putaway complete CTAs).
+ * Matches what callers can actually invoke successfully:
+ * - HTTP floor on complete + scan/putaway requires `wms.adjust_inventory`
+ * - Command then allows manage (any task) or adjust + assignee match
+ * Manage-only without adjust must not see Complete (would 403 on the route).
+ */
+export function canShowPutawayCompleteAction(input: {
+  canManagePutaway: boolean
+  canAdjustInventory: boolean
+  isAssignee: boolean
+}): boolean {
+  if (!input.canAdjustInventory) return false
+  return input.canManagePutaway || input.isAssignee
+}
+
+function toCloseableLines(lines: AsnCompleteGateLine[]) {
+  return lines.map((line) => ({
+    expectedQty: line.expected_qty ?? 0,
+    receivedQty: line.received_qty ?? 0,
+    qcStatus: line.qc_status,
+  }))
+}
+
+/**
+ * Complete ASN affordance aligned with `wms.asns.close` / `isAsnCloseable`:
+ * - Show when manage + open ASN + any receipt activity (empty / untouched lines hide Complete)
+ * - Enable default submit only when QC-passed accepted qty meets expected on every line
+ * - When short / QC-fail, expose close-when-short and enable submit only after that opt-in
+ *   (avoids enabling a default Complete that always 409s as invalid_receipt_state)
+ * - Header-only / zero-activity ASNs stay non-closeable (isAsnCloseable requires receipt activity)
+ */
+export function resolveAsnCompleteGate(input: {
+  canManageAsn: boolean
+  asnStatus: string | null | undefined
+  lines: AsnCompleteGateLine[]
+  closeWhenShort: boolean
+}): {
+  canShowComplete: boolean
+  canSubmitComplete: boolean
+  showCloseWhenShort: boolean
+} {
+  const closeableLines = toCloseableLines(input.lines)
+  const canReceiveMore = input.asnStatus === 'draft' || input.asnStatus === 'in_transit'
+  const canShowComplete =
+    input.canManageAsn && canReceiveMore && hasAsnReceiptActivity(closeableLines)
+  if (!canShowComplete) {
+    return {
+      canShowComplete: false,
+      canSubmitComplete: false,
+      showCloseWhenShort: false,
+    }
+  }
+
+  const fullyCloseable = isAsnCloseable(closeableLines, false)
+  return {
+    canShowComplete: true,
+    canSubmitComplete: isAsnCloseable(closeableLines, input.closeWhenShort),
+    showCloseWhenShort: !fullyCloseable,
+  }
+}

package/src/modules/wms/components/backend/inventoryMutationLoaders.ts

@@ -405,6 +405,26 @@ export async function loadBinLocationOptions(
   }
 }
 
+export async function loadStagingLocationOptions(
+  warehouseId: string,
+  query?: string,
+): Promise<CrudFieldOption[]> {
+  if (!warehouseId) return []
+  try {
+    const [staging, dock] = await Promise.all([
+      loadLocationPage(warehouseId, { type: 'staging', search: query }),
+      loadLocationPage(warehouseId, { type: 'dock', search: query }),
+    ])
+    const byId = new Map<string, CrudFieldOption>()
+    for (const option of mapLocationOptions([...(staging.items ?? []), ...(dock.items ?? [])])) {
+      byId.set(option.value, option)
+    }
+    return Array.from(byId.values())
+  } catch {
+    return []
+  }
+}
+
 export async function loadZoneOptions(
   warehouseId: string,
   query?: string,

package/src/modules/wms/components/backend/putawayQueueOptimisticLock.ts

@@ -0,0 +1,20 @@
+import { extractOptimisticLockConflict } from '@open-mercato/ui/backend/utils/optimisticLock'
+
+/**
+ * Apply a 409 optimistic-lock `currentUpdatedAt` into a mutable token map so
+ * putaway queue assign/start/cancel retries send a fresh If-Match.
+ * Returns the refreshed token, or null when the response is not a lock conflict.
+ */
+export function applyPutawayLockTokenFromConflict(
+  tokens: Record<string, string>,
+  taskId: string,
+  response: { status: number; body: unknown },
+): string | null {
+  const conflict = extractOptimisticLockConflict({
+    status: response.status,
+    body: response.body,
+  })
+  if (!conflict?.currentUpdatedAt) return null
+  tokens[taskId] = conflict.currentUpdatedAt
+  return conflict.currentUpdatedAt
+}

package/src/modules/wms/components/backend/useWmsInventoryMutationAccess.ts

@@ -35,6 +35,8 @@ export function useWmsInventoryMutationAccess() {
               'wms.adjust_inventory',
               'wms.manage_inventory',
               'wms.receive_inventory',
+              'wms.manage_asn',
+              'wms.manage_putaway',
               'wms.cycle_count',
               'wms.import',
               'wms.manage_reservations',
@@ -75,6 +77,8 @@ export function useWmsInventoryMutationAccess() {
     canAdjust: hasFeature(granted, 'wms.adjust_inventory'),
     canManage: hasFeature(granted, 'wms.manage_inventory'),
     canReceive: hasFeature(granted, 'wms.receive_inventory'),
+    canManageAsn: hasFeature(granted, 'wms.manage_asn'),
+    canManagePutaway: hasFeature(granted, 'wms.manage_putaway'),
     canCycleCount: hasFeature(granted, 'wms.cycle_count'),
     canImport: hasFeature(granted, 'wms.import'),
     canMove: hasFeature(granted, 'wms.adjust_inventory'),

package/src/modules/wms/data/enrichers.ts

@@ -5,6 +5,8 @@ import type { FeatureTogglesService } from '@open-mercato/core/modules/feature_t
 import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
 import { E } from '#generated/entities.ids.generated'
 import { InventoryBalance, InventoryReservation, ProductInventoryProfile, SalesOrderWarehouseAssignment, Warehouse } from './entities'
+import { formatCatalogVariantLabel } from '../lib/inventoryDisplayUi'
+import { isBalanceLocationReservable } from '../lib/inventoryPolicy'
 import { resolvePrimaryWarehouseId } from '../lib/primaryWarehousePolicy'
 import {
   WMS_ENRICHER_CACHE_TTL_MS,
@@ -28,7 +30,21 @@ type SalesOrderLineRow = {
 type CatalogVariantRow = {
   id?: string
   product_id?: string | null
+  name?: string | null
+  sku?: string | null
 }
+
+type ReservationSummaryItem = {
+  id: string
+  reservationLabel: string
+  catalogVariantId: string
+  warehouseId: string | null
+  warehouseName: string | null
+  quantity: string
+  variantName: string | null
+  variantSku: string | null
+}
+
 type ReservationStatus = 'unreserved' | 'partially_reserved' | 'fully_reserved'
 type ReorderState = 'no_profile' | 'healthy' | 'below_reorder_point' | 'below_safety_stock'
 
@@ -60,6 +76,11 @@ type ReorderStatus = {
   safetyStock: string
 }
 
+type InboundSummary = {
+  openAsnCount: number
+  nextExpectedAt: string | null
+}
+
 type SalesOrderWmsEnrichment = {
   _wms: {
     assignedWarehouseId: string | null
@@ -73,7 +94,9 @@ type SalesOrderWmsEnrichment = {
     reservationSummary: {
       status: ReservationStatus
       reservationIds: string[]
+      reservations: ReservationSummaryItem[]
     }
+    inboundSummary: InboundSummary
   }
 }
 
@@ -90,6 +113,11 @@ type Scope = { organizationId: string; tenantId: string }
 type BalanceAggregate = { onHand: number; reserved: number; allocated: number; available: number }
 
 import { resolveWmsIntegrationToggleEnabled } from '../lib/wmsIntegrationToggles'
+const EMPTY_INBOUND_SUMMARY: InboundSummary = {
+  openAsnCount: 0,
+  nextExpectedAt: null,
+}
+
 const EMPTY_ENRICHMENT: SalesOrderWmsEnrichment = {
   _wms: {
     assignedWarehouseId: null,
@@ -99,7 +127,9 @@ const EMPTY_ENRICHMENT: SalesOrderWmsEnrichment = {
     reservationSummary: {
       status: 'unreserved',
       reservationIds: [],
+      reservations: [],
     },
+    inboundSummary: EMPTY_INBOUND_SUMMARY,
   },
 }
 
@@ -167,6 +197,55 @@ function resolveReservationStatus(requiredQuantity: number, reservedQuantity: nu
   return 'fully_reserved'
 }
 
+function buildReservationLabel(input: {
+  id: string
+  variantName: string | null
+  variantSku: string | null
+  warehouseName: string | null
+  quantity: string
+}): string {
+  const variantLabel = formatCatalogVariantLabel({
+    variant_name: input.variantName,
+    variant_sku: input.variantSku,
+  })
+  const segments: string[] = []
+  if (variantLabel && variantLabel !== '—') segments.push(variantLabel)
+  const warehouseName = input.warehouseName?.trim()
+  if (warehouseName) segments.push(warehouseName)
+  const quantity = formatQuantity(Number(input.quantity))
+  if (quantity !== '0') segments.push(quantity)
+  return segments.length > 0 ? segments.join(' · ') : input.id
+}
+
+function toReservationSummaryItem(
+  reservation: InventoryReservation,
+  warehouseNamesById: Map<string, string>,
+  variantLabelsById: Map<string, { name: string | null; sku: string | null }>,
+): ReservationSummaryItem {
+  const warehouseId = extractWarehouseId(reservation)
+  const warehouseName = warehouseId ? (warehouseNamesById.get(warehouseId) ?? null) : null
+  const variantMeta = variantLabelsById.get(reservation.catalogVariantId)
+  const variantName = variantMeta?.name ?? null
+  const variantSku = variantMeta?.sku ?? null
+  const quantity = formatQuantity(Number(reservation.quantity))
+  return {
+    id: reservation.id,
+    reservationLabel: buildReservationLabel({
+      id: reservation.id,
+      variantName,
+      variantSku,
+      warehouseName,
+      quantity,
+    }),
+    catalogVariantId: reservation.catalogVariantId,
+    warehouseId,
+    warehouseName,
+    quantity,
+    variantName,
+    variantSku,
+  }
+}
+
 function resolveReorderStatus(
   availableQuantity: number,
   profile: ProductInventoryProfile | null | undefined,
@@ -204,6 +283,10 @@ function buildBalanceSummaryByVariant(
   const byVariant = new Map<string, BalanceAggregate>()
 
   for (const balance of balances) {
+    // Match reservation / sales-automation: staging/dock are inbound holding
+    // and must not inflate widget "Available" (or sellable on-hand aggregates).
+    if (!isBalanceLocationReservable(balance)) continue
+
     const current = byVariant.get(balance.catalogVariantId) ?? {
       onHand: 0,
       reserved: 0,
@@ -254,6 +337,31 @@ async function isSalesOrderInventoryEnabled(context: EnricherContext): Promise<b
   }
 }
 
+async function loadInboundSummary(em: EntityManager, scope: Scope): Promise<InboundSummary> {
+  // Aggregate only — never load all open ASN rows (backlog can blow the enricher timeout).
+  const rows = await em.getConnection().execute<
+    Array<{ open_asn_count: string | number; next_expected_at: Date | string | null }>
+  >(
+    `select count(*)::int as open_asn_count,
+            min(expected_at) as next_expected_at
+     from wms_asns
+     where organization_id = ?
+       and tenant_id = ?
+       and deleted_at is null
+       and status in ('draft', 'in_transit')`,
+    [scope.organizationId, scope.tenantId],
+  )
+  const row = rows[0]
+  const openAsnCount = Number(row?.open_asn_count ?? 0)
+  const nextExpected = row?.next_expected_at
+  return {
+    openAsnCount: Number.isFinite(openAsnCount) ? openAsnCount : 0,
+    nextExpectedAt: nextExpected
+      ? (nextExpected instanceof Date ? nextExpected : new Date(nextExpected)).toISOString()
+      : null,
+  }
+}
+
 async function loadExplicitAssignments(
   em: EntityManager,
   orderIds: string[],
@@ -352,7 +460,8 @@ async function loadBalances(
       tenantId: scope.tenantId,
       deletedAt: null,
     },
-    undefined,
+    // Populate location so isBalanceLocationReservable can exclude staging/dock.
+    { populate: ['location'] },
     scope,
   )
 }
@@ -376,6 +485,32 @@ async function loadCatalogVariants(
   return result.items
 }
 
+async function loadCatalogVariantLabelsByIds(
+  context: EnricherContext,
+  variantIds: string[],
+  scope: Scope,
+): Promise<Map<string, { name: string | null; sku: string | null }>> {
+  if (variantIds.length === 0) return new Map()
+  const container = context.container as { resolve: (name: string) => unknown }
+  const queryEngine = container.resolve('queryEngine') as QueryEngine
+  const result = await queryEngine.query<CatalogVariantRow>(E.catalog.catalog_product_variant, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    filters: { id: { $in: variantIds } },
+    fields: ['id', 'name', 'sku'],
+    page: { page: 1, pageSize: Math.max(variantIds.length, 1) },
+  })
+  const labels = new Map<string, { name: string | null; sku: string | null }>()
+  for (const row of result.items) {
+    if (typeof row.id !== 'string' || row.id.length === 0) continue
+    labels.set(row.id, {
+      name: typeof row.name === 'string' ? row.name : null,
+      sku: typeof row.sku === 'string' ? row.sku : null,
+    })
+  }
+  return labels
+}
+
 async function loadProductInventoryProfiles(
   em: EntityManager,
   productIds: string[],
@@ -462,12 +597,16 @@ const salesOrderInventoryEnricher: ResponseEnricher<SalesOrderRecord, SalesOrder
       ),
     )
 
-    const [reservations, balances, primaryWarehouseId, explicitAssignments] = await Promise.all([
-      loadReservations(em, orderIds, scope),
-      loadBalances(em, variantIds, scope),
-      resolvePrimaryWarehouseId(em, scope),
-      loadExplicitAssignments(em, orderIds, scope),
-    ])
+    // inboundSummary is best-effort (raw ASN SQL); isolate so a missing table /
+    // migration lag cannot reject the whole Promise.all and drop stock/reservation.
+    const [reservations, balances, primaryWarehouseId, explicitAssignments, inboundSummary] =
+      await Promise.all([
+        loadReservations(em, orderIds, scope),
+        loadBalances(em, variantIds, scope),
+        resolvePrimaryWarehouseId(em, scope),
+        loadExplicitAssignments(em, orderIds, scope),
+        loadInboundSummary(em, scope).catch(() => EMPTY_INBOUND_SUMMARY),
+      ])
 
     const explicitWarehouseIdsByOrder = new Map<string, string>()
     for (const assignment of explicitAssignments) {
@@ -491,14 +630,31 @@ const salesOrderInventoryEnricher: ResponseEnricher<SalesOrderRecord, SalesOrder
     const warehouses = await loadWarehousesByIds(em, allRelevantWarehouseIds, scope)
     const warehouseNamesById = new Map(warehouses.map((w) => [w.id, w.name]))
 
+    const activeReservationVariantIds = Array.from(
+      new Set(
+        reservations
+          .filter((reservation) => reservation.status === 'active')
+          .map((reservation) => reservation.catalogVariantId)
+          .filter((value): value is string => typeof value === 'string' && value.length > 0),
+      ),
+    )
+    const variantLabelsById = await loadCatalogVariantLabelsByIds(
+      context,
+      activeReservationVariantIds,
+      scope,
+    )
+
     const variantAvailability = new Map<string, number>()
     const variantReserved = new Map<string, number>()
     for (const balance of balances) {
-      addToMap(
-        variantAvailability,
-        balance.catalogVariantId,
-        Number(balance.quantityOnHand) - Number(balance.quantityReserved) - Number(balance.quantityAllocated),
-      )
+      // Staging/dock must not count toward Available (same rule as reserve path).
+      if (isBalanceLocationReservable(balance)) {
+        addToMap(
+          variantAvailability,
+          balance.catalogVariantId,
+          Number(balance.quantityOnHand) - Number(balance.quantityReserved) - Number(balance.quantityAllocated),
+        )
+      }
       addToMap(variantReserved, balance.catalogVariantId, balance.quantityReserved)
     }
 
@@ -564,6 +720,10 @@ const salesOrderInventoryEnricher: ResponseEnricher<SalesOrderRecord, SalesOrder
         ? (warehouseNamesById.get(assignedWarehouseId) ?? null)
         : null
 
+      const reservationItems = reservationsForOrder.map((reservation) =>
+        toReservationSummaryItem(reservation, warehouseNamesById, variantLabelsById),
+      )
+
       return {
         ...record,
         _wms: {
@@ -580,8 +740,10 @@ const salesOrderInventoryEnricher: ResponseEnricher<SalesOrderRecord, SalesOrder
               requiredBySalesOrder.get(orderId) ?? 0,
               reservedBySalesOrder.get(orderId) ?? 0,
             ),
-            reservationIds: reservationsForOrder.map((reservation) => reservation.id),
+            reservationIds: reservationItems.map((item) => item.id),
+            reservations: reservationItems,
           },
+          inboundSummary,
         },
       }
     })