universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/landmark-global/numbers.json

@@ -0,0 +1,58 @@
+{
+  "carrier": "landmark-global",
+  "records": [
+    {
+      "number": "LTN480634985",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6ab3ef95f2b298d50182689a",
+        "date": "2026-09-23"
+      },
+      "expect": {
+        "carrier": "landmark-global",
+        "confidence": "high"
+      },
+      "note": "The anonymous native tracking page identifies this reference as a Landmark parcel."
+    },
+    {
+      "number": "LTN74207623N1",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/landmark.json"
+      },
+      "expect": {
+        "carrier": "landmark-global",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LTN74209518N1",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/landmark.json"
+      },
+      "expect": {
+        "carrier": "landmark-global",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LTN74224021N1",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/landmark.json"
+      },
+      "expect": {
+        "carrier": "landmark-global",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    }
+  ]
+}

package/dist/carriers/landmark-global/parser.d.ts

@@ -0,0 +1,3 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeLandmarkNumber(raw: string): string;
+export declare function parseLandmark(html: string, rawNumber: string): CarrierResult;

package/dist/carriers/landmark-global/parser.js

@@ -0,0 +1,78 @@
+import { load } from 'cheerio';
+import { DateTime } from 'luxon';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { ChallengeError, IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { clean } from '../../core/transport/index.js';
+import { landmarkStatus } from './status.js';
+const ABSENT = "We couldn't find a match for this value. Please try a different value.";
+export function normalizeLandmarkNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!/^LTN\d{8,9}(?:N1)?$/.test(number))
+        throw new TypeError('Landmark requires an LTN parcel reference');
+    return number;
+}
+function clock(raw) {
+    const validated = /^\d{4}-\d{2}-\d{2} (?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$/.test(raw)
+        ? DateTime.fromFormat(raw, 'yyyy-MM-dd HH:mm:ss', { zone: 'UTC' }) : null;
+    if (!validated?.isValid)
+        return raw ? { provider_time_text: raw } : {};
+    return { local_time: validated.toISO({ includeOffset: false, suppressMilliseconds: true }) };
+}
+export function parseLandmark(html, rawNumber) {
+    const number = normalizeLandmarkNumber(rawNumber);
+    const canonical = number.replace(/N1$/, '');
+    const $ = load(html);
+    if (/just a moment|verify.*human|captcha/i.test($('title').text()) || $('.g-recaptcha,.h-captcha').length)
+        throw new ChallengeError('Landmark Global');
+    $('script,style,noscript').remove();
+    const identities = $('.delivery-details-col h6').filter((_, node) => clean($(node).text()) === 'Landmark Tracking Number');
+    const tables = $('.event-summary .event-table table');
+    const errors = $('.error-text').map((_, node) => clean($(node).text())).get().filter(Boolean);
+    if (!identities.length && !tables.length && $('#search').length === 1 && $('#search').val() === number
+        && errors.length && errors.every(error => error === ABSENT) && $('title').text().trim() === 'Landmark Global | Landmark Tracking')
+        throw new NotFoundError('Landmark Global');
+    if (identities.length !== 1 || clean(identities.next('div').text()) !== canonical)
+        throw new SchemaError('Landmark Global', 'Landmark returned a different or ambiguous parcel');
+    if (tables.length !== 1 || tables.find('thead th').map((_, node) => clean($(node).text())).get().join('|') !== 'Description|Date/Time|Location')
+        throw new SchemaError('Landmark Global');
+    const rows = tables.find('tbody > tr');
+    if (!rows.length)
+        throw new IndeterminateError('Landmark Global', 'Landmark returned no parcel history');
+    if (rows.length > 500)
+        throw new SchemaError('Landmark Global', 'Landmark returned excessive parcel history');
+    const firstCells = rows.first().children('td');
+    const summary = $('.current-status');
+    if (summary.length !== 1 || clean(summary.find('h3').text()) !== clean(firstCells.eq(0).text())
+        || summary.find('.time').attr('data-time') !== firstCells.eq(1).attr('data-time'))
+        throw new IndeterminateError('Landmark Global', 'Landmark latest summary does not match its first scan');
+    const events = [];
+    const seen = new Set();
+    for (const row of rows.toArray()) {
+        const cells = $(row).children('td');
+        if (cells.length !== 3 || cells.filter('[colspan]').length)
+            throw new SchemaError('Landmark Global');
+        const wording = clean(cells.eq(0).text(), 500);
+        if (!wording)
+            throw new SchemaError('Landmark Global', 'Landmark returned an empty scan');
+        const mapped = landmarkStatus(wording);
+        const event = { ...clock(clean(cells.eq(1).attr('data-time') ?? cells.eq(1).text(), 64)),
+            description: mapped?.stage === 'delivered' ? 'Delivered' : wording, location: clean(cells.eq(2).text(), 200),
+            ...(mapped ? { stage: mapped.stage } : {}) };
+        const key = JSON.stringify(event);
+        if (!seen.has(key)) {
+            seen.add(key);
+            events.push(event);
+        }
+    }
+    const latest = events[0];
+    const current = landmarkStatus(clean(firstCells.eq(0).text(), 500));
+    const partner = $('.delivery-details-col h6').filter((_, node) => clean($(node).text()) === 'Delivery Partner').next('div');
+    const inputs = partner.find('input[name="id"]');
+    const partnerNumber = partner.length === 1 && inputs.length === 1 ? clean(inputs.val(), 64).toUpperCase() : '';
+    const partnerName = clean(partner.clone().find('form').remove().end().text(), 100);
+    return { status: current?.status ?? 'unknown', ...(current ? { current_stage: current.stage } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null, last_update_local: latest.local_time ?? null, expected_delivery: null,
+        ...(number !== canonical ? { canonical_tracking_number: canonical } : {}),
+        ...(/^[A-Z0-9]{4,40}$/.test(partnerNumber) ? { delivery_tracking_number: partnerNumber,
+            ...(partnerName === 'Australia Post' ? { delivery_carrier: 'australia-post' } : {}) } : {}), events: events.slice(0, 100) };
+}

package/dist/carriers/landmark-global/status.d.ts

@@ -0,0 +1,2 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function landmarkStatus(wording: string): ClassifiedStatus | undefined;

package/dist/carriers/landmark-global/status.js

@@ -0,0 +1,13 @@
+const WORDINGS = new Map([
+    ['Delivered', { status: 'delivered', stage: 'delivered' }],
+    ['Delivered to your community mailbox, parcel locker or apt./condo mailbox', { status: 'delivered', stage: 'delivered' }],
+    ...['Onboard for delivery', 'Item out for delivery'].map(wording => [wording, { status: 'out_for_delivery', stage: 'out_for_delivery' }]),
+    ['Shipment Data Uploaded', { status: 'pending', stage: 'registered' }],
+    ['Transmitted customs information', { status: 'in_transit', stage: 'customs' }],
+    ...['Customs cleared', 'Item processed at facility', 'Item processed', 'Received in destination country',
+        'Crossing border and in transit to carrier hub', 'Scanned at Landmark crossdock facility', 'Processed',
+        'Shipment received at originating postal facility', 'Departure to country of destination', 'Shipment has arrived at depot',
+        'Received at international processing center', 'Incoming scan at facility', 'Shipment has departed from airport',
+        'Shipment has departed from depot'].map(wording => [wording, { status: 'in_transit', stage: 'in_transit' }]),
+]);
+export function landmarkStatus(wording) { return WORDINGS.get(wording); }

package/dist/carriers/landmark-global/statuses.json

@@ -0,0 +1,125 @@
+{
+  "carrier": "landmark-global",
+  "entries": [
+    {
+      "wording": "Delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Delivered to your community mailbox, parcel locker or apt./condo mailbox",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Onboard for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Item out for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment Data Uploaded",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Transmitted customs information",
+      "language": "en",
+      "stage": "customs",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Customs cleared",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Item processed at facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Item processed",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Received in destination country",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Crossing border and in transit to carrier hub",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Scanned at Landmark crossdock facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Processed",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment received at originating postal facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Departure to country of destination",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment has arrived at depot",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Received at international processing center",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Incoming scan at facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment has departed from airport",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment has departed from depot",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    }
+  ]
+}

package/dist/carriers/mondial-relay/adapter.d.ts

@@ -0,0 +1,32 @@
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+import { TrawlClient } from '../../core/transport/index.js';
+interface MondialRelayCredential {
+    shipment: string;
+    postcode: string;
+    canonicalShipment?: string;
+}
+export declare function normalizeMondialRelayCredential(rawShipment: string, rawPostcode?: string): MondialRelayCredential;
+export declare function mondialRelayTrackingUrl(rawShipment: string, rawPostcode?: string): string;
+export declare function parseMondialRelayTrackingResponse(payload: unknown, rawShipment: string, rawPostcode?: string): CarrierResult;
+export interface MondialRelayTrackerOptions {
+    timeoutMs?: number;
+    directTimeoutMs?: number;
+    /** Legacy configuration seam; `trawl` is preferred. */
+    trawlUrl?: string;
+    /** The browser service, or null when none is configured. */
+    trawl?: TrawlClient | null;
+    fetcher?: typeof fetch;
+    recorder?: StepRecorder;
+}
+export declare class MondialRelayTracker {
+    #private;
+    readonly timeoutMs: number;
+    readonly directTimeoutMs: number;
+    readonly trawlUrl: string;
+    constructor(options?: MondialRelayTrackerOptions);
+    fetch(rawShipment: string, rawPostcode?: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;
+export {};

package/dist/carriers/mondial-relay/adapter.js

@@ -0,0 +1,352 @@
+import { load } from 'cheerio';
+import { DateTime } from 'luxon';
+import { isValidMondialRelayBarcode } from '../../core/detection/index.js';
+import { ChallengeError, InputRequiredError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { runSteps, singleFlight } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { isoTime, zonedTime } from '../../core/time/index.js';
+import { cleanScalar, TrawlClient, trawlBody } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyStatus, milestoneNumberStatus } from './status.js';
+// Protocol provenance (inspected 2026-08-30):
+// https://www.mondialrelay.fr/versioned-assets/2nMAiuVI9Rv9J3kZacblPYCfCABwzS-qZ3m7eFBQn4A/Scripts/vue/tracking/js/app.js
+// SHA-256: da73008ae548f51bfd27791969c6e53d809f080070cd2faa6779bb7850509f80
+// The current official bundle reads the server-rendered `token` attribute from
+// #tracking and sends it as RequestVerificationToken to GET /api/tracking.
+// Mondial Relay's current CONNECT guide documents 8-, 10-, and 12-digit IDs:
+// https://www.mondialrelay.fr/media/124728/fr-documentation-utilisateur-connect-v-12.pdf
+const TRACKING_PAGE = 'https://www.mondialrelay.fr/suivi-de-colis/';
+const TRACKING_API = 'https://www.mondialrelay.fr/api/tracking';
+const MAX_DIRECT_BYTES = 2_000_000;
+const MAX_TRAWL_BYTES = 10_000_000;
+const DEFAULT_TIMEOUT_MS = 90_000;
+const DEFAULT_DIRECT_TIMEOUT_MS = 20_000;
+const ZONE = 'Europe/Paris';
+const CREDENTIAL_MESSAGE = 'Mondial Relay tracking requires an 8-, 10-, or 12-digit shipment number followed by '
+    + 'the 5-digit recipient postcode';
+/** Strip the markup Mondial Relay embeds in its labels, entities included. */
+function plainText(value, limit = 500) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return '';
+    const raw = String(value).slice(0, Math.max(limit * 10, 5_000));
+    return cleanScalar(load(raw).text(), limit);
+}
+function plausibleFrenchPostcode(value) {
+    return /^(?:0[1-9]|[1-8]\d|9[0-5]|97|98)\d{3}$/.test(value);
+}
+export function normalizeMondialRelayCredential(rawShipment, rawPostcode = '') {
+    let shipment = rawShipment.trim().replace(/[\s.-]/g, '');
+    let postcode = rawPostcode.trim();
+    if (/^\d{26}$/.test(shipment)) {
+        if (!isValidMondialRelayBarcode(shipment) || (postcode && !plausibleFrenchPostcode(postcode))) {
+            throw new SchemaError('Mondial Relay', 'Invalid Mondial Relay barcode or postcode');
+        }
+        // The public alias carries brand/shipment/parcel sequence, not a postcode.
+        return { shipment: shipment.slice(0, 12), postcode, canonicalShipment: shipment.slice(2, 10) };
+    }
+    if (!postcode && /^(?:\d{13}|\d{15}|\d{17})$/.test(shipment)) {
+        postcode = shipment.slice(-5);
+        shipment = shipment.slice(0, -5);
+    }
+    const shapedShipment = /^(?:\d{8}|\d{10}|\d{12})$/.test(shipment);
+    if (!shapedShipment || !plausibleFrenchPostcode(postcode)) {
+        // A well-shaped number without a usable postcode is a missing credential;
+        // anything else is a number this carrier cannot address at all.
+        throw shapedShipment
+            ? new InputRequiredError('Mondial Relay', 'the recipient postcode', CREDENTIAL_MESSAGE)
+            : new SchemaError('Mondial Relay', CREDENTIAL_MESSAGE);
+    }
+    // The longer forms put the 2-digit brand before the 8-digit shipment (the
+    // 12-digit one adds the parcel sequence), and the API echoes the shipment.
+    return shipment.length > 8
+        ? { shipment, postcode, canonicalShipment: shipment.slice(2, 10) }
+        : { shipment, postcode };
+}
+export function mondialRelayTrackingUrl(rawShipment, rawPostcode = '') {
+    const credential = normalizeMondialRelayCredential(rawShipment, rawPostcode);
+    const url = new URL(TRACKING_PAGE);
+    url.searchParams.set('numeroExpedition', credential.shipment);
+    return url.toString();
+}
+function trackingApiUrl(credential, brand = '') {
+    const url = new URL(TRACKING_API);
+    url.searchParams.set('shipment', credential.shipment);
+    url.searchParams.set('postcode', credential.postcode);
+    url.searchParams.set('brand', brand);
+    url.searchParams.set('codePays', 'fr');
+    return url.toString();
+}
+function verificationToken(html) {
+    const $ = load(html);
+    const token = cleanScalar($('#tracking').first().attr('token'), 4_096);
+    if (!/^[A-Za-z0-9:_-]{20,4096}$/.test(token)) {
+        throw new ChallengeError('Mondial Relay', 'Mondial Relay did not issue a request token');
+    }
+    return token;
+}
+/**
+ * An event timestamp. Mondial Relay sends offset-less Paris wall-clock time in
+ * several shapes; a bare calendar day is kept as a day, because stamping
+ * midnight on it would invent a precision the provider did not give.
+ */
+function eventTime(value) {
+    const raw = cleanScalar(value, 64);
+    if (!raw)
+        return null;
+    if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        const day = isoTime(raw, ZONE);
+        return day ? { iso: raw, timestamp: day.timestamp } : null;
+    }
+    return isoTime(raw, ZONE)
+        ?? zonedTime(raw, 'dd/MM/yyyy HH:mm:ss', ZONE)
+        ?? zonedTime(raw, 'dd/MM/yyyy HH:mm', ZONE)
+        ?? zonedTime(raw, 'dd/MM/yyyy', ZONE);
+}
+/**
+ * The delivery estimate, reduced to its calendar day. None of the core time
+ * policies fits: they all return an instant, and the estimate is read in Paris
+ * even when it carries an offset, as the provider sends it offset-less.
+ */
+function expectedDelivery(value) {
+    const raw = cleanScalar(value, 64);
+    if (!raw || raw.startsWith('0001-01-01'))
+        return null;
+    const date = DateTime.fromISO(raw, { zone: ZONE });
+    return date.isValid ? date.toISODate() : null;
+}
+function parseEvents(expedition) {
+    if (!Array.isArray(expedition.Evenements))
+        return [];
+    const parsed = [];
+    const seen = new Set();
+    expedition.Evenements.forEach((rawEvent, index) => {
+        if (!isRecord(rawEvent))
+            return;
+        const time = eventTime(rawEvent.Date);
+        const description = plainText(rawEvent.Libelle);
+        if (!time || !description)
+            return;
+        const identity = JSON.stringify([time.iso, description]);
+        if (seen.has(identity))
+            return;
+        seen.add(identity);
+        const classified = classifyStatus(description);
+        parsed.push({
+            event: {
+                time: time.iso,
+                location: '',
+                description,
+                stage: classified.stage,
+            },
+            classified,
+            timestamp: time.timestamp,
+            index,
+        });
+    });
+    parsed.sort((left, right) => right.timestamp - left.timestamp || left.index - right.index);
+    return parsed.slice(0, 100);
+}
+function milestoneStatus(expedition) {
+    if (!isRecord(expedition.SuiviParEtapes))
+        return null;
+    const reached = [];
+    for (const raw of Object.values(expedition.SuiviParEtapes)) {
+        if (!isRecord(raw) || !isRecord(raw.Evenement) || !cleanScalar(raw.Evenement.Date, 64))
+            continue;
+        const number = Number(raw.Numero);
+        const classified = classifyStatus(plainText(raw.Libelle));
+        if (Number.isFinite(number))
+            reached.push({ number, status: classified });
+    }
+    reached.sort((left, right) => right.number - left.number);
+    const latest = reached[0];
+    if (!latest)
+        return null;
+    if (latest.status.status !== 'unknown')
+        return latest.status;
+    return milestoneNumberStatus(latest.number);
+}
+export function parseMondialRelayTrackingResponse(payload, rawShipment, rawPostcode = '') {
+    return parseTrackingResponse(payload, normalizeMondialRelayCredential(rawShipment, rawPostcode));
+}
+function parseTrackingResponse(payload, credential) {
+    if (!isRecord(payload))
+        throw new SchemaError('Mondial Relay');
+    if (!isRecord(payload.Expedition)) {
+        const warning = Array.isArray(payload.status)
+            && payload.status.some((entry) => isRecord(entry) && cleanScalar(entry.state, 32) === 'warn');
+        // The provider echoes the query in that warning; only the fact is kept.
+        if (warning || Array.isArray(payload.FiltresRecherche))
+            throw new NotFoundError('Mondial Relay');
+        throw new SchemaError('Mondial Relay', 'Mondial Relay returned incomplete tracking details');
+    }
+    const expedition = payload.Expedition;
+    const returnedShipment = cleanScalar(expedition.Numero, 32).replace(/\s/g, '');
+    if (!/^(?:\d{8}|\d{10}|\d{12})$/.test(returnedShipment)) {
+        throw new SchemaError('Mondial Relay', 'Mondial Relay returned an invalid shipment number');
+    }
+    if (returnedShipment !== credential.shipment && returnedShipment !== credential.canonicalShipment) {
+        throw new SchemaError('Mondial Relay', 'Mondial Relay returned a different shipment');
+    }
+    const parsedEvents = parseEvents(expedition);
+    const events = parsedEvents.map(({ event }) => event);
+    const contextual = plainText(expedition.SuiviContextuel);
+    const statusText = contextual || events[0]?.description || 'Tracking information received';
+    const contextualStatus = classifyStatus(statusText);
+    const current = contextualStatus.status !== 'unknown'
+        ? contextualStatus
+        : parsedEvents.find((event) => event.classified.status !== 'unknown')?.classified
+            ?? milestoneStatus(expedition);
+    const status = current?.status ?? 'unknown';
+    return {
+        status,
+        // The status vocabulary has no pickup value; without the stage the sync
+        // would re-read the headline and fall back to "out for delivery".
+        ...(current ? { current_stage: current.stage } : {}),
+        last_status_text: statusText,
+        last_update: events[0]?.time ?? null,
+        expected_delivery: ['delivered', 'exception'].includes(status)
+            ? null
+            : expectedDelivery(expedition.EstimatedDeliveryDate),
+        timezone: ZONE,
+        events,
+        source: 'mondial_relay_public_web',
+    };
+}
+/**
+ * The page the browser actually loaded. Mondial Relay's Vue app replaces the
+ * `#tracking` root as soon as it boots, so the captured response body carries
+ * the server-rendered token that the rendered HTML no longer has.
+ */
+function originalTrawlPage(response) {
+    const body = trawlBody(response.raw, MAX_DIRECT_BYTES);
+    return body.includes('id="tracking"') || body.includes("id='tracking'") ? body : response.html;
+}
+function trawlJson(response) {
+    const candidates = [trawlBody(response.raw, MAX_DIRECT_BYTES)];
+    const $ = load(response.html);
+    candidates.push($('pre').first().text(), $('body').text(), response.html);
+    for (const candidate of candidates) {
+        const cleaned = candidate.trim().replace(/^/, '');
+        if (!cleaned)
+            continue;
+        try {
+            return JSON.parse(cleaned);
+        }
+        catch {
+            // Try the next representation. Browser navigations wrap JSON in a <pre>.
+        }
+    }
+    throw new SchemaError('Mondial Relay', 'Mondial Relay browser fallback returned invalid tracking data');
+}
+function assertTrawlTarget(response, expectedUrl) {
+    const returned = cleanScalar(response.url, 2_048);
+    if (!returned)
+        return;
+    let actual;
+    let expected;
+    try {
+        actual = new URL(returned);
+        expected = new URL(expectedUrl);
+    }
+    catch (error) {
+        throw new SchemaError('Mondial Relay', 'Mondial Relay browser fallback returned an invalid URL', { cause: error });
+    }
+    if (actual.origin !== expected.origin
+        || actual.pathname !== expected.pathname
+        || actual.searchParams.get('shipment') !== expected.searchParams.get('shipment')
+        || actual.searchParams.get('postcode') !== expected.searchParams.get('postcode')) {
+        throw new SchemaError('Mondial Relay', 'Mondial Relay browser fallback returned a different shipment');
+    }
+}
+export class MondialRelayTracker {
+    timeoutMs;
+    directTimeoutMs;
+    trawlUrl;
+    #trawl;
+    #fetcher;
+    #recorder;
+    #serialize = singleFlight();
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.directTimeoutMs = Math.max(1_000, Math.min(this.timeoutMs, options.directTimeoutMs ?? DEFAULT_DIRECT_TIMEOUT_MS));
+        this.trawlUrl = (options.trawlUrl ?? '').trim();
+        this.#trawl = options.trawl;
+        this.#fetcher = options.fetcher;
+        this.#recorder = options.recorder ?? NOOP_RECORDER;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new TypeError('Mondial Relay timeout must be positive');
+        }
+    }
+    /** The injected browser service, or one built from the configured URL. */
+    #browserService() {
+        if (this.#trawl !== undefined)
+            return this.#trawl;
+        return this.trawlUrl ? new TrawlClient(this.trawlUrl, this.#fetcher) : null;
+    }
+    async fetch(rawShipment, rawPostcode = '') {
+        // One lookup at a time: the page token and the API call have to stay on the
+        // same solved browser identity.
+        return this.#serialize(() => this.#lookup(normalizeMondialRelayCredential(rawShipment, rawPostcode)));
+    }
+    async #lookup(credential) {
+        // Cloudflare blocks every non-browser client with an HTTP 403 WAF block
+        // (verified from multiple networks, 2026-09-10), so a direct attempt only
+        // burns time and reports a fallback on each sync. There is one step, and
+        // it is the browser.
+        const trawl = this.#browserService();
+        if (!trawl) {
+            throw new ChallengeError('Mondial Relay', 'Mondial Relay challenged direct tracking; configure FLARESOLVERR_URL for browser fallback');
+        }
+        return runSteps({
+            carrier: 'mondial-relay', budgetMs: this.timeoutMs, recorder: this.#recorder,
+        }, [
+            { id: 'trawl', run: () => this.#trawlResult(trawl, credential) },
+        ]);
+    }
+    async #trawlResult(trawl, credential) {
+        const bootstrap = await this.#scrape(trawl, { url: TRACKING_PAGE });
+        const token = verificationToken(originalTrawlPage(bootstrap));
+        const apiUrl = trackingApiUrl(credential);
+        const tracked = await this.#scrape(trawl, {
+            url: apiUrl,
+            headers: {
+                Accept: 'application/json, text/plain, */*',
+                'Accept-Language': 'fr-FR,fr;q=0.9',
+                Referer: TRACKING_PAGE,
+                RequestVerificationToken: token,
+            },
+        });
+        assertTrawlTarget(tracked, apiUrl);
+        return this.#finish(trawlJson(tracked), credential, 'browser-session-response');
+    }
+    #scrape(trawl, request) {
+        return trawl.scrape({ skipHttp: true, maxTier: 3, maxTimeout: this.timeoutMs, ...request }, {
+            provider: 'TRAWL while fetching Mondial Relay',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_TRAWL_BYTES,
+            fetcher: this.#fetcher,
+        });
+    }
+    #finish(payload, credential, trackingSource) {
+        const result = parseTrackingResponse(payload, credential);
+        const url = new URL(TRACKING_PAGE);
+        url.searchParams.set('numeroExpedition', credential.shipment);
+        result.tracking_url = url.toString();
+        result.tracking_source = trackingSource;
+        return result;
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new MondialRelayTracker({
+        fetcher: environment.fetcher,
+        trawl: environment.trawl,
+        recorder: environment.recorder,
+    });
+    return {
+        id: 'mondial-relay',
+        // Cloudflare refuses every non-browser client, so there is no direct tier.
+        steps: ['trawl'],
+        track: (input) => tracker.fetch(input.number, input.postcode ?? ''),
+    };
+};