feat(warehouse): Batch 6 — Export Loaded queue + Dispatch Queue with bulk dispatch

- GET /warehouse-inventory/loaded-export: EXPORT+LOADED items (route-derived direction)
- POST /warehouse-inventory/bulk-dispatch-export: reuses existing dispatch() transition
  (LOADED → DISPATCHED, capacity freed, movement/activity logged); skips non-LOADED/non-EXPORT
- Extracted shared exportInventoryByStatus() helper (readyToLoadExport now delegates to it)
- Frontend LoadedExportTab serves both Loaded (read-only) and Dispatch Queue (dispatchable)
  sub-tabs with Dispatch / Dispatch Selected / Dispatch All + per-row Dispatch
- Replaces "Loaded" and "Dispatch Queue — coming in the next batch" placeholders
- Train/schedule flow (DISPATCHED → IN_TRANSIT) unchanged

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts

@@ -84,6 +84,18 @@ export class WarehouseInventoryController {
     return this.inventoryService.readyToLoadExport();
   }
 
+  @Get('loaded-export')
+  @ApiOperation({ summary: 'EXPORT inventory that is LOADED and queued for dispatch' })
+  loadedExport() {
+    return this.inventoryService.loadedExport();
+  }
+
+  @Post('bulk-dispatch-export')
+  @ApiOperation({ summary: 'Bulk-dispatch loaded EXPORT inventory (LOADED → DISPATCHED)' })
+  bulkDispatchExport(@Body() dto: { inventoryIds: string[]; performedBy?: string }) {
+    return this.inventoryService.bulkDispatchExport(dto.inventoryIds ?? [], dto.performedBy);
+  }
+
   @Post('bulk-mark-inspected')
   @ApiOperation({ summary: 'Bulk mark received inventory inspection PASSED (EXPORT → READY_FOR_LOADING)' })
   bulkMarkInspected(@Body() dto: BulkInspectDto) {

apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts

@@ -169,6 +169,12 @@ export interface ReadyToLoadRow {
   status: string;
 }
 
+export interface BulkDispatchResult {
+  dispatchedCount: number;
+  skippedCount: number;
+  results: { inventoryId: string; status: string; reason?: string }[];
+}
+
 @Injectable()
 export class WarehouseInventoryService {
   constructor(
@@ -616,8 +622,11 @@ export class WarehouseInventoryService {
     return result;
   }
 
-  /** EXPORT inventory that passed inspection and is waiting to be loaded (READY_FOR_LOADING). */
-  async readyToLoadExport(): Promise<ReadyToLoadRow[]> {
+  /** EXPORT inventory rows at a given status (route-derived direction), with booking detail. */
+  private async exportInventoryByStatus(
+    status: WarehouseInventoryStatus,
+    requireInspectionPassed = false,
+  ): Promise<ReadyToLoadRow[]> {
     const rows: Array<
       ReadyToLoadRow & { originCountry: string | null; destinationCountry: string | null }
     > = await this.dataSource.query(
@@ -643,9 +652,10 @@ export class WarehouseInventoryService {
          LEFT JOIN freight.cargo_types cgt ON cgt.id = b.cargo_type_id
          LEFT JOIN freight.containers ct ON ct.id = inv.container_id
         WHERE inv.deleted_at IS NULL
-          AND inv.status = 'READY_FOR_LOADING'
-          AND inv.inspection_status = 'PASSED'
+          AND inv.status = $1
+          ${requireInspectionPassed ? `AND inv.inspection_status = 'PASSED'` : ''}
         ORDER BY inv.created_at DESC`,
+      [status],
     );
 
     return rows
@@ -656,6 +666,48 @@ export class WarehouseInventoryService {
       .map(({ originCountry: _oc, destinationCountry: _dc, ...rest }) => rest);
   }
 
+  /** EXPORT inventory that passed inspection and is waiting to be loaded (READY_FOR_LOADING). */
+  async readyToLoadExport(): Promise<ReadyToLoadRow[]> {
+    return this.exportInventoryByStatus('READY_FOR_LOADING', true);
+  }
+
+  /** EXPORT inventory that has been loaded onto a wagon and is queued for dispatch (LOADED). */
+  async loadedExport(): Promise<ReadyToLoadRow[]> {
+    return this.exportInventoryByStatus('LOADED');
+  }
+
+  /**
+   * Bulk-dispatch loaded EXPORT inventory. Reuses the single-item dispatch transition
+   * (status LOADED → DISPATCHED, capacity freed, movement/activity logged). Items not
+   * LOADED or not EXPORT are skipped. The train/schedule flow later moves DISPATCHED → IN_TRANSIT.
+   */
+  async bulkDispatchExport(inventoryIds: string[], performedBy?: string): Promise<BulkDispatchResult> {
+    const result: BulkDispatchResult = { dispatchedCount: 0, skippedCount: 0, results: [] };
+
+    for (const inventoryId of inventoryIds) {
+      const skip = (reason: string) => {
+        result.skippedCount += 1;
+        result.results.push({ inventoryId, status: 'SKIPPED', reason });
+      };
+
+      const item = await this.inventoryRepository.findById(inventoryId);
+      if (!item) { skip('Inventory not found'); continue; }
+      if (item.status !== 'LOADED') { skip(`Status is ${item.status}, not LOADED`); continue; }
+      const direction = item.bookingId ? await this.getBookingDirection(item.bookingId) : null;
+      if (direction !== 'EXPORT') { skip('Not an EXPORT item'); continue; }
+
+      try {
+        await this.dispatch(inventoryId, performedBy);
+        result.dispatchedCount += 1;
+        result.results.push({ inventoryId, status: 'DISPATCHED' });
+      } catch (error) {
+        skip(error instanceof Error ? error.message : String(error));
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Bulk-mark received items inspection PASSED (reusing the inspection service to create a minimal
    * report + sync inspectionStatus/inspectedAt). EXPORT items advance straight to READY_FOR_LOADING.