add Group 9 delivery scenarios for self-haul and last-mile paths

- Implemented G9·S38 tests for customer self-haul truck assignments, ensuring compliance with container limits and truck assignments.
- Added G9·S39 tests for last-mile delivery, self-haul, and yard pickup, verifying independent paths for multiple bookings on the same train.
- Created seed data for Group 1 and Group 2 scenarios, ensuring proper setup for weight and capacity tests.
- Updated booking interface to deprecate  in favor of  for better clarity in allocations.

apps/edr-freight-api/src/main.ts

@@ -1,6 +1,7 @@
 import "reflect-metadata";
 import * as dotenv from "dotenv";
 dotenv.config();
+import { createRequire } from "node:module";
 import { NestFactory } from "@nestjs/core";
 import type { NestExpressApplication } from "@nestjs/platform-express";
 import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
@@ -20,6 +21,62 @@ import { AppModule } from "./app.module";
  */
 const JSON_BODY_LIMIT = '20mb';
 
+/**
+ * Static /etc/hosts-style overrides from `DNS_HOST_OVERRIDES`, formatted as
+ * `host=ip,host2=ip2`. Some internal hosts (MinIO) resolve only inside the
+ * deployment network, so dev machines get ENOTFOUND on every upload. Patching
+ * `dns.lookup` keeps the real hostname on the wire — the IP is used for the
+ * connection only — so TLS still validates against the certificate's CN.
+ *
+ * The module is loaded through `createRequire`, NOT `import * as dns`: an ESM
+ * namespace object is frozen, so assigning to it is silently dropped and the
+ * patch becomes a no-op. `require` returns the live module object every other
+ * caller (minio's http agent included) reads `lookup` off.
+ */
+function applyDnsHostOverrides(): void {
+  const raw = process.env.DNS_HOST_OVERRIDES?.trim();
+  if (!raw) return;
+
+  const overrides = new Map<string, string>();
+  for (const entry of raw.split(",")) {
+    const [host, ip] = entry.split("=").map((part) => part?.trim());
+    if (host && ip) overrides.set(host.toLowerCase(), ip);
+  }
+  if (overrides.size === 0) return;
+
+  const dns = createRequire(__filename)("node:dns") as typeof import("node:dns");
+  const originalLookup = dns.lookup.bind(dns);
+  // `dns.lookup` is overloaded (options optional, all/family variants); the
+  // cast keeps that surface intact while we intercept only mapped hostnames.
+  (dns as { lookup: unknown }).lookup = ((
+    hostname: string,
+    options: unknown,
+    callback?: unknown,
+  ) => {
+    const ip = overrides.get(hostname?.toLowerCase?.());
+    if (!ip) return (originalLookup as Function)(hostname, options, callback);
+
+    const done = (typeof options === "function" ? options : callback) as (
+      err: NodeJS.ErrnoException | null,
+      address: string | { address: string; family: number }[],
+      family?: number,
+    ) => void;
+    const family = ip.includes(":") ? 6 : 4;
+    const wantsAll =
+      typeof options === "object" && options !== null && (options as { all?: boolean }).all;
+
+    process.nextTick(() =>
+      wantsAll ? done(null, [{ address: ip, family }]) : done(null, ip, family),
+    );
+  }) as typeof dns.lookup;
+
+  console.log(
+    `[DNS] Host overrides active: ${[...overrides].map(([h, ip]) => `${h}->${ip}`).join(", ")}`,
+  );
+}
+
+applyDnsHostOverrides();
+
 async function bootstrap() {
   const app = await NestFactory.create<NestExpressApplication>(AppModule);