DJbouti port Export Unloading

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

@@ -15,6 +15,7 @@ import { WarehouseZone } from './warehouse-zone.entity';
 //   IMPORT:          READY_FOR_PICKUP → DELIVERED (release order + proof of delivery)
 export const WAREHOUSE_INVENTORY_STATUSES = [
   'UNLOADED',
+  'UNLOADED_AT_DJIBOUTI_PORT',
   'RECEIVED',
   'STORED',
   'RESERVED',
@@ -31,12 +32,13 @@ export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, W
   // UNLOADED = train-arrival landing state (Batch 8). Not yet stored/inspected.
   // Mirrors RECEIVED so the import flow can store or go straight to pickup after inspection.
   UNLOADED: ['STORED', 'READY_FOR_PICKUP'],
+  UNLOADED_AT_DJIBOUTI_PORT: [],
   RECEIVED: ['STORED', 'READY_FOR_PICKUP'],
   STORED: ['RESERVED'],
   RESERVED: ['READY_FOR_LOADING'],
   READY_FOR_LOADING: ['LOADED'],
   LOADED: ['DISPATCHED'],
-  DISPATCHED: [],
+  DISPATCHED: ['UNLOADED_AT_DJIBOUTI_PORT'],
   // Batch 10: an inspected import item can leave by customer pickup (DELIVERED) or be dispatched
   // out by EDR (DISPATCHED) — kept separate — or be put into storage (STORED) if no one collects
   // it / customs or inspection hold / operator chooses to store.

apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts

@@ -37,6 +37,36 @@ export interface ImportTrainItemRow {
   lastMileRequested: boolean;
   pickupOption: string;
 }
+
+export interface ExportDjiboutiQueueFilter {
+  scheduleId?: string;
+  destination?: string;
+  status?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}
+
+export interface ExportTrainRow extends ImportTrainRow {
+  departureTime: string | null;
+}
+
+export interface ExportTrainItemRow {
+  bookingId: string;
+  bookingReference: string | null;
+  customerId: string | null;
+  customerName: string | null;
+  itemType: 'CONTAINER' | 'CARGO';
+  itemId: string | null;
+  inventoryId: string | null;
+  containerNumber: string | null;
+  cargoType: string | null;
+  weight: number | null;
+  origin: string | null;
+  destination: string | null;
+  trainSchedule: string | null;
+  arrivalTime: string | null;
+  currentStatus: string | null;
+}
 export interface WagonView {
   id: string;
   wagonNumber: string;
@@ -67,6 +97,13 @@ export interface BookingScheduleView {
 export class SchedulingReadFacade {
   constructor(private readonly dataSource: DataSource) {}
 
+  private isDjiboutiPortDestination(value: string | null | undefined): boolean {
+    const normalized = (value ?? '').toUpperCase();
+    return ['DJIBOUTI', 'DORALEH', 'DMP', 'DCT', 'NAGAD'].some((token) =>
+      normalized.includes(token),
+    );
+  }
+
   /** Look up a single physical wagon. Returns null if it does not exist. */
   async findWagon(wagonId: string): Promise<WagonView | null> {
     const rows = await this.dataSource.query(
@@ -220,4 +257,187 @@ export class SchedulingReadFacade {
     );
     return rows;
   }
+
+  /**
+   * ARRIVED export train schedules at Djibouti-side destinations, with assigned item counts.
+   * Read-only: this only selects from scheduling/booking/inventory tables.
+   */
+  async exportDjiboutiArrivalQueue(
+    filter: ExportDjiboutiQueueFilter = {},
+  ): Promise<ExportTrainRow[]> {
+    const params: unknown[] = [];
+    const where = [
+      'ts.deleted_at IS NULL',
+      "ts.status = ANY($1)",
+      `EXISTS (
+        SELECT 1
+          FROM freight.train_schedule_bookings tsb_exists
+          JOIN freight.bookings b_exists ON b_exists.id = tsb_exists.booking_id AND b_exists.deleted_at IS NULL
+          LEFT JOIN freight.warehouse_inventory inv_exists ON inv_exists.booking_id = b_exists.id AND inv_exists.deleted_at IS NULL
+         WHERE tsb_exists.train_schedule_id = ts.id
+           AND tsb_exists.deleted_at IS NULL
+           AND (inv_exists.status = ANY($2) OR b_exists.status = ANY($2))
+      )`,
+    ];
+    params.push(
+      filter.status ? [filter.status] : ['ARRIVED', 'ARRIVED_AT_DJIBOUTI'],
+      ['DISPATCHED', 'IN_TRANSIT', 'ARRIVED_AT_DJIBOUTI', 'ARRIVED_AT_PORT', 'ARRIVED_AT_DESTINATION'],
+    );
+
+    if (filter.scheduleId) {
+      params.push(filter.scheduleId);
+      where.push(`ts.id = $${params.length}`);
+    }
+    if (filter.destination) {
+      params.push(`%${filter.destination}%`);
+      where.push(`(dy.code ILIKE $${params.length} OR dy.name ILIKE $${params.length})`);
+    }
+    if (filter.dateFrom) {
+      params.push(filter.dateFrom);
+      where.push(`COALESCE(ts.actual_arrival_at, ts.scheduled_arrival_date) >= $${params.length}`);
+    }
+    if (filter.dateTo) {
+      params.push(filter.dateTo);
+      where.push(`COALESCE(ts.actual_arrival_at, ts.scheduled_arrival_date) <= $${params.length}`);
+    }
+
+    const rows: Array<
+      ExportTrainRow & {
+        originCountry: string | null;
+        destinationCountry: string | null;
+        destinationName: string | null;
+      }
+    > = await this.dataSource.query(
+      `SELECT ts.id                  AS "scheduleId",
+              ts.train_number         AS "trainNumber",
+              oy.code                 AS "origin",
+              dy.code                 AS "destination",
+              dy.name                 AS "destinationName",
+              oy.country              AS "originCountry",
+              dy.country              AS "destinationCountry",
+              ts.scheduled_departure_date AS "departureTime",
+              COALESCE(ts.actual_arrival_at, ts.scheduled_arrival_date) AS "arrivalTime",
+              ts.status,
+              (SELECT count(*) FROM freight.train_schedule_bookings tsb
+                 WHERE tsb.train_schedule_id = ts.id AND tsb.deleted_at IS NULL) AS "totalBookings",
+              (SELECT count(*) FROM freight.containers c
+                 JOIN freight.train_schedule_bookings tsbc ON tsbc.booking_id = c.booking_id AND tsbc.deleted_at IS NULL
+                WHERE tsbc.train_schedule_id = ts.id AND c.deleted_at IS NULL) AS "totalContainers",
+              (SELECT count(*) FROM freight.cargoes cg
+                 JOIN freight.train_schedule_bookings tsbg ON tsbg.booking_id = cg.booking_id AND tsbg.deleted_at IS NULL
+                WHERE tsbg.train_schedule_id = ts.id AND cg.deleted_at IS NULL) AS "totalCargoes"
+         FROM freight.train_schedules ts
+         LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
+         LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
+        WHERE ${where.join(' AND ')}
+        ORDER BY COALESCE(ts.actual_arrival_at, ts.scheduled_arrival_date) DESC NULLS LAST`,
+      params,
+    );
+
+    return rows
+      .filter((r) => {
+        const direction = deriveTradeDirection(
+          { country: r.originCountry },
+          { country: r.destinationCountry },
+        );
+        return (
+          direction === 'EXPORT' &&
+          this.isDjiboutiPortDestination(`${r.destination ?? ''} ${r.destinationName ?? ''}`)
+        );
+      })
+      .map(({ originCountry: _oc, destinationCountry: _dc, destinationName: _dn, ...rest }) => ({
+        ...rest,
+        totalBookings: Number(rest.totalBookings) || 0,
+        totalContainers: Number(rest.totalContainers) || 0,
+        totalCargoes: Number(rest.totalCargoes) || 0,
+        route: rest.origin || rest.destination ? `${rest.origin ?? '?'} -> ${rest.destination ?? '?'}` : null,
+      }));
+  }
+
+  /** Assigned export booking items for an arrived Djibouti-side export train. Read-only. */
+  async exportDjiboutiTrainDetail(scheduleId: string): Promise<ExportTrainItemRow[]> {
+    const rows: ExportTrainItemRow[] = await this.dataSource.query(
+      `WITH assigned AS (
+          SELECT b.id AS booking_id,
+                 b.reference,
+                 b.company_id,
+                 company.name AS customer_name,
+                 COALESCE(cgt.cargo_type_name, b.cargo_free_text) AS cargo_type,
+                 b.cargo_total_weight_vgm AS booking_weight,
+                 oy.code AS origin,
+                 dy.code AS destination,
+                 ts.train_number,
+                 COALESCE(ts.actual_arrival_at, ts.scheduled_arrival_date) AS arrival_time,
+                 inv.id AS inventory_id,
+                 COALESCE(inv.status, b.status) AS current_status
+            FROM freight.train_schedule_bookings tsb
+            JOIN freight.train_schedules ts ON ts.id = tsb.train_schedule_id
+            JOIN freight.bookings b ON b.id = tsb.booking_id AND b.deleted_at IS NULL
+            LEFT JOIN freight.companies company ON company.id = b.company_id
+            LEFT JOIN freight.cargo_types cgt ON cgt.id = b.cargo_type_id
+            LEFT JOIN freight.yards oy ON oy.id = b.origin_yard_id
+            LEFT JOIN freight.yards dy ON dy.id = b.destination_yard_id
+            LEFT JOIN freight.warehouse_inventory inv ON inv.booking_id = b.id AND inv.deleted_at IS NULL
+           WHERE tsb.train_schedule_id = $1 AND tsb.deleted_at IS NULL
+        )
+        SELECT a.booking_id AS "bookingId",
+               a.reference AS "bookingReference",
+               a.company_id AS "customerId",
+               a.customer_name AS "customerName",
+               'CONTAINER' AS "itemType",
+               c.id AS "itemId",
+               a.inventory_id AS "inventoryId",
+               c.container_number AS "containerNumber",
+               a.cargo_type AS "cargoType",
+               a.booking_weight AS "weight",
+               a.origin,
+               a.destination,
+               a.train_number AS "trainSchedule",
+               a.arrival_time AS "arrivalTime",
+               a.current_status AS "currentStatus"
+          FROM assigned a
+          JOIN freight.containers c ON c.booking_id = a.booking_id AND c.deleted_at IS NULL
+        UNION ALL
+        SELECT a.booking_id AS "bookingId",
+               a.reference AS "bookingReference",
+               a.company_id AS "customerId",
+               a.customer_name AS "customerName",
+               'CARGO' AS "itemType",
+               cg.id AS "itemId",
+               a.inventory_id AS "inventoryId",
+               NULL AS "containerNumber",
+               COALESCE(cgt.cargo_type_name, a.cargo_type) AS "cargoType",
+               COALESCE(cg.weight, a.booking_weight) AS "weight",
+               a.origin,
+               a.destination,
+               a.train_number AS "trainSchedule",
+               a.arrival_time AS "arrivalTime",
+               a.current_status AS "currentStatus"
+          FROM assigned a
+          JOIN freight.cargoes cg ON cg.booking_id = a.booking_id AND cg.deleted_at IS NULL
+          LEFT JOIN freight.cargo_types cgt ON cgt.id = cg.cargo_type_id
+        UNION ALL
+        SELECT a.booking_id AS "bookingId",
+               a.reference AS "bookingReference",
+               a.company_id AS "customerId",
+               a.customer_name AS "customerName",
+               CASE WHEN a.cargo_type ILIKE '%container%' THEN 'CONTAINER' ELSE 'CARGO' END AS "itemType",
+               a.inventory_id AS "itemId",
+               a.inventory_id AS "inventoryId",
+               NULL AS "containerNumber",
+               a.cargo_type AS "cargoType",
+               a.booking_weight AS "weight",
+               a.origin,
+               a.destination,
+               a.train_number AS "trainSchedule",
+               a.arrival_time AS "arrivalTime",
+               a.current_status AS "currentStatus"
+          FROM assigned a
+         WHERE NOT EXISTS (SELECT 1 FROM freight.containers c WHERE c.booking_id = a.booking_id AND c.deleted_at IS NULL)
+           AND NOT EXISTS (SELECT 1 FROM freight.cargoes cg WHERE cg.booking_id = a.booking_id AND cg.deleted_at IS NULL)
+         ORDER BY "bookingReference" ASC NULLS LAST, "itemType" ASC`,
+      [scheduleId],
+    );
+    return rows;
+  }
 }

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

@@ -143,6 +143,36 @@ export class WarehouseInventoryController {
     return this.inventoryService.importUnloadedQueue();
   }
 
+  @Get('export/djibouti-arrival-queue')
+  @ApiOperation({ summary: 'Arrived EXPORT train schedules at Djibouti-side ports, ready for unloading' })
+  exportDjiboutiArrivalQueue(
+    @Query('scheduleId') scheduleId?: string,
+    @Query('destination') destination?: string,
+    @Query('status') status?: string,
+    @Query('dateFrom') dateFrom?: string,
+    @Query('dateTo') dateTo?: string,
+  ) {
+    return this.scheduling.exportDjiboutiArrivalQueue({
+      scheduleId,
+      destination,
+      status,
+      dateFrom,
+      dateTo,
+    });
+  }
+
+  @Get('export/djibouti-trains/:scheduleId/items')
+  @ApiOperation({ summary: 'Assigned export bookings/items for an arrived Djibouti-side train' })
+  exportDjiboutiTrainDetail(@Param('scheduleId', ParseUUIDPipe) scheduleId: string) {
+    return this.scheduling.exportDjiboutiTrainDetail(scheduleId);
+  }
+
+  @Post('export/auto-unload-at-djibouti')
+  @ApiOperation({ summary: 'Unload all eligible export items assigned to an arrived Djibouti-side train' })
+  autoUnloadExportAtDjibouti(@Body() dto: { scheduleId: string; performedBy?: string }) {
+    return this.inventoryService.autoUnloadExportAtDjibouti(dto.scheduleId, dto.performedBy);
+  }
+
   @Get('import/pickup-ready-queue')
   @ApiOperation({ summary: 'IMPORT inventory that is PICKUP_READY (READY_FOR_PICKUP) awaiting pickup/dispatch' })
   importPickupReadyQueue() {

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

@@ -235,6 +235,22 @@ export interface AutoUnloadArrivedResult {
   results: { bookingId: string; inventoryId?: string; status: string; reason?: string }[];
 }
 
+export interface AutoUnloadExportDjiboutiResult {
+  unloadedCount: number;
+  skippedCount: number;
+  failedCount: number;
+  results: Array<{
+    bookingId: string;
+    itemType: 'CONTAINER' | 'CARGO';
+    itemId?: string | null;
+    inventoryId?: string;
+    containerNumber?: string | null;
+    status: string;
+    message?: string;
+    reason?: string;
+  }>;
+}
+
 export interface ImportUnloadedRow {
   id: string;
   bookingId: string | null;
@@ -869,6 +885,20 @@ export class WarehouseInventoryService {
 
   /** Booking statuses that must never be unloaded into warehouse inventory. */
   private readonly IMPORT_UNLOAD_BLOCKED_STATUSES = ['DRAFT', 'REJECTED', 'CANCELLED', 'COMPLETED'];
+  private readonly EXPORT_DJIBOUTI_UNLOAD_ELIGIBLE_STATUSES = [
+    'DISPATCHED',
+    'IN_TRANSIT',
+    'ARRIVED_AT_DJIBOUTI',
+    'ARRIVED_AT_PORT',
+    'ARRIVED_AT_DESTINATION',
+  ];
+
+  private isDjiboutiPortDestination(value: string | null | undefined): boolean {
+    const normalized = (value ?? '').toUpperCase();
+    return ['DJIBOUTI', 'DORALEH', 'DMP', 'DCT', 'NAGAD'].some((token) =>
+      normalized.includes(token),
+    );
+  }
 
   /**
    * Batch 8 — unload all eligible assigned bookings of an ARRIVED import train into UNLOADED state.
@@ -1010,6 +1040,225 @@ export class WarehouseInventoryService {
     return result;
   }
 
+  /**
+   * Unload eligible EXPORT inventory from an arrived Djibouti-side train.
+   * This only advances warehouse inventory items assigned to the train and does not write to
+   * train schedules, wagon assignment, rescheduling, or booking payment state.
+   */
+  async autoUnloadExportAtDjibouti(
+    scheduleId: string,
+    performedBy?: string,
+  ): Promise<AutoUnloadExportDjiboutiResult> {
+    const result: AutoUnloadExportDjiboutiResult = {
+      unloadedCount: 0,
+      skippedCount: 0,
+      failedCount: 0,
+      results: [],
+    };
+
+    const [schedule] = await this.dataSource.query(
+      `SELECT ts.id,
+              ts.status,
+              oy.country AS "originCountry",
+              dy.country AS "destinationCountry",
+              dy.code AS "destinationCode",
+              dy.name AS "destinationName"
+         FROM freight.train_schedules ts
+         LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
+         LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
+        WHERE ts.id = $1 AND ts.deleted_at IS NULL
+        LIMIT 1`,
+      [scheduleId],
+    );
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    const direction = deriveTradeDirection(
+      { country: schedule.originCountry },
+      { country: schedule.destinationCountry },
+    );
+    if (direction !== 'EXPORT') {
+      throw new BadRequestException(`Train schedule route is ${direction}, not EXPORT`);
+    }
+    if (!this.isDjiboutiPortDestination(`${schedule.destinationCode ?? ''} ${schedule.destinationName ?? ''}`)) {
+      throw new BadRequestException('Train schedule destination is not Djibouti / Doraleh / DMP / DCT / Nagad');
+    }
+    if (!['ARRIVED', 'ARRIVED_AT_DJIBOUTI'].includes(schedule.status)) {
+      throw new BadRequestException(`Train schedule is ${schedule.status}, not ARRIVED`);
+    }
+
+    const items: Array<{
+      bookingId: string;
+      inventoryId: string | null;
+      inventoryStatus: string | null;
+      bookingStatus: string | null;
+      warehouseId: string | null;
+      yardId: string | null;
+      zoneId: string | null;
+      itemType: 'CONTAINER' | 'CARGO';
+      itemId: string | null;
+      containerNumber: string | null;
+    }> = await this.dataSource.query(
+      `WITH assigned AS (
+          SELECT b.id AS booking_id,
+                 b.status AS booking_status,
+                 inv.id AS inventory_id,
+                 inv.status AS inventory_status,
+                 inv.warehouse_id,
+                 inv.yard_id,
+                 inv.zone_id
+            FROM freight.train_schedule_bookings tsb
+            JOIN freight.bookings b ON b.id = tsb.booking_id AND b.deleted_at IS NULL
+            LEFT JOIN freight.warehouse_inventory inv ON inv.booking_id = b.id AND inv.deleted_at IS NULL
+           WHERE tsb.train_schedule_id = $1 AND tsb.deleted_at IS NULL
+        )
+        SELECT a.booking_id AS "bookingId",
+               a.inventory_id AS "inventoryId",
+               a.inventory_status AS "inventoryStatus",
+               a.booking_status AS "bookingStatus",
+               a.warehouse_id AS "warehouseId",
+               a.yard_id AS "yardId",
+               a.zone_id AS "zoneId",
+               'CONTAINER' AS "itemType",
+               c.id AS "itemId",
+               c.container_number AS "containerNumber"
+          FROM assigned a
+          JOIN freight.containers c ON c.booking_id = a.booking_id AND c.deleted_at IS NULL
+        UNION ALL
+        SELECT a.booking_id AS "bookingId",
+               a.inventory_id AS "inventoryId",
+               a.inventory_status AS "inventoryStatus",
+               a.booking_status AS "bookingStatus",
+               a.warehouse_id AS "warehouseId",
+               a.yard_id AS "yardId",
+               a.zone_id AS "zoneId",
+               'CARGO' AS "itemType",
+               cg.id AS "itemId",
+               NULL AS "containerNumber"
+          FROM assigned a
+          JOIN freight.cargoes cg ON cg.booking_id = a.booking_id AND cg.deleted_at IS NULL
+        UNION ALL
+        SELECT a.booking_id AS "bookingId",
+               a.inventory_id AS "inventoryId",
+               a.inventory_status AS "inventoryStatus",
+               a.booking_status AS "bookingStatus",
+               a.warehouse_id AS "warehouseId",
+               a.yard_id AS "yardId",
+               a.zone_id AS "zoneId",
+               'CARGO' AS "itemType",
+               a.inventory_id AS "itemId",
+               NULL AS "containerNumber"
+          FROM assigned a
+         WHERE NOT EXISTS (SELECT 1 FROM freight.containers c WHERE c.booking_id = a.booking_id AND c.deleted_at IS NULL)
+           AND NOT EXISTS (SELECT 1 FROM freight.cargoes cg WHERE cg.booking_id = a.booking_id AND cg.deleted_at IS NULL)`,
+      [scheduleId],
+    );
+
+    const seenInventory = new Set<string>();
+    const now = new Date();
+
+    await this.dataSource.transaction(async (manager) => {
+      for (const item of items) {
+        const skip = (reason: string) => {
+          result.skippedCount += 1;
+          result.results.push({
+            bookingId: item.bookingId,
+            itemType: item.itemType,
+            itemId: item.itemId,
+            inventoryId: item.inventoryId ?? undefined,
+            containerNumber: item.containerNumber,
+            status: 'SKIPPED',
+            reason,
+          });
+        };
+        const fail = (reason: string) => {
+          result.failedCount += 1;
+          result.results.push({
+            bookingId: item.bookingId,
+            itemType: item.itemType,
+            itemId: item.itemId,
+            inventoryId: item.inventoryId ?? undefined,
+            containerNumber: item.containerNumber,
+            status: 'FAILED',
+            reason,
+          });
+        };
+
+        if (!item.inventoryId || !item.warehouseId || !item.yardId || !item.zoneId) {
+          skip('No warehouse inventory found for assigned export item');
+          continue;
+        }
+        if (seenInventory.has(item.inventoryId)) {
+          result.results.push({
+            bookingId: item.bookingId,
+            itemType: item.itemType,
+            itemId: item.itemId,
+            inventoryId: item.inventoryId,
+            containerNumber: item.containerNumber,
+            status: 'UNLOADED_AT_DJIBOUTI_PORT',
+            message: 'Unloaded at Djibouti Port',
+          });
+          continue;
+        }
+
+        const currentStatus = item.inventoryStatus ?? item.bookingStatus;
+        if (!currentStatus || !this.EXPORT_DJIBOUTI_UNLOAD_ELIGIBLE_STATUSES.includes(currentStatus)) {
+          skip(`Status ${currentStatus ?? 'UNKNOWN'} is not eligible for Djibouti export unloading`);
+          continue;
+        }
+
+        try {
+          await manager.getRepository(WarehouseInventory).update(item.inventoryId, {
+            status: 'UNLOADED_AT_DJIBOUTI_PORT',
+            unloadedAt: now,
+            arrivedAt: now,
+            notes: 'Unloaded at Djibouti Port',
+          });
+          await manager.getRepository(WarehouseInventoryMovement).save(
+            manager.getRepository(WarehouseInventoryMovement).create({
+              inventoryId: item.inventoryId,
+              fromWarehouseId: item.warehouseId,
+              fromYardId: item.yardId,
+              fromZoneId: item.zoneId,
+              toWarehouseId: item.warehouseId,
+              toYardId: item.yardId,
+              toZoneId: item.zoneId,
+              remarks: 'EXPORT_UNLOADED_AT_DJIBOUTI_PORT',
+              movedBy: performedBy ?? null,
+              movedAt: now,
+            }),
+          );
+          await this.activityLog.record(
+            {
+              activityType: 'INVENTORY_UNLOADED',
+              inventoryId: item.inventoryId,
+              warehouseId: item.warehouseId,
+              description: 'EXPORT_UNLOADED_AT_DJIBOUTI_PORT',
+              performedBy,
+            },
+            manager,
+          );
+          seenInventory.add(item.inventoryId);
+          result.unloadedCount += 1;
+          result.results.push({
+            bookingId: item.bookingId,
+            itemType: item.itemType,
+            itemId: item.itemId,
+            inventoryId: item.inventoryId,
+            containerNumber: item.containerNumber,
+            status: 'UNLOADED_AT_DJIBOUTI_PORT',
+            message: 'Unloaded at Djibouti Port',
+          });
+        } catch (error) {
+          fail(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.