universal-parcel-scraper 0.11.0 → 0.13.0-main.337

package/dist/carriers/cne/parser.js

@@ -0,0 +1,74 @@
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { classifyWording, languageStageStatus } from '../../core/status/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean, cleanScalar } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+const PROVIDER = 'CNE Express';
+const WORDING = {
+    'Parcel Infomation Received': 'registered', 'Picked Up by Courier': 'accepted',
+    'Shipment Loaded': 'in_transit', 'Departed CNE Facility': 'in_transit',
+    'Arrived at CNE Facility': 'in_transit', 'Inbound scan': 'in_transit',
+    'Shipment Processed': 'in_transit', 'Sorting failed []': 'exception',
+    "It was returned to customer's address by CNE": 'returned',
+};
+export function normalizeCneNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!/^[A-Z0-9]{6,40}$/.test(number))
+        throw new InvalidInputError(PROVIDER, 'CNE requires an alphanumeric parcel reference');
+    return number;
+}
+function scanTime(value) {
+    const match = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-](\d{2}):?(\d{2}))$/i.exec(value);
+    if (!match || (match[1] !== undefined && (Number(match[1]) > 14 || Number(match[2]) > 59
+        || (Number(match[1]) === 14 && Number(match[2]) !== 0))))
+        return null;
+    return explicitOffsetTime(value);
+}
+function scan(raw) {
+    if (!isRecord(raw) || !clean(raw.details, 1000))
+        throw new SchemaError(PROVIDER, 'CNE returned an invalid movement');
+    const description = clean(raw.details, 1000), clock = clean(raw.date, 64);
+    const location = clean(raw.place, 200), stage = WORDING[description];
+    const mapped = stage ? { stage, source: 'carrier_map' } : classifyWording(description, 'pending');
+    const time = scanTime(clock);
+    return { description, ...(location ? { location } : {}),
+        ...(time ? { time: time.iso } : clock ? { provider_time_text: clock } : {}),
+        ...(mapped.source !== 'none' ? { stage: mapped.stage, stage_source: mapped.source } : {}),
+        ...(cleanScalar(raw.state) ? { provider_code: cleanScalar(raw.state) } : {}) };
+}
+export function parseCne(payload, raw) {
+    const number = normalizeCneNumber(raw);
+    if (!isRecord(payload) || typeof payload.ReturnValue !== 'number')
+        throw new SchemaError(PROVIDER, 'CNE returned an invalid envelope');
+    if (payload.ReturnValue !== 1) {
+        if (payload.ReturnValue === 0 && payload.cMess === '订单不存在'
+            && payload.Response_Info === undefined && payload.trackingEventList === undefined)
+            throw new NotFoundError(PROVIDER);
+        throw new IndeterminateError(PROVIDER, 'CNE did not complete the lookup');
+    }
+    const identity = payload.Response_Info;
+    if (!isRecord(identity) || clean(identity.trackingNbr) !== number)
+        throw new SchemaError(PROVIDER, 'CNE returned a different shipment');
+    // These are echoed source identifiers, unlike referNbr and transNbr, which
+    // may be merchant and downstream references. Do not follow those aliases.
+    if (identity.Number_t !== undefined && clean(identity.Number_t) !== number)
+        throw new SchemaError(PROVIDER, 'CNE returned conflicting shipment identifiers');
+    if (!Array.isArray(payload.trackingEventList) || payload.trackingEventList.length > 1000)
+        throw new SchemaError(PROVIDER, 'CNE returned an invalid history');
+    if (!payload.trackingEventList.length)
+        throw new IndeterminateError(PROVIDER, 'CNE returned no shipment movements');
+    // The official client reverses the oldest-first array. Preserve that order
+    // even when its unqualified cross-border clocks cannot resolve to instants.
+    const events = payload.trackingEventList.map(scan).reverse();
+    const latest = events[0];
+    const summaryStage = cleanScalar(identity.status) === '8' ? 'returned' : undefined;
+    const stage = summaryStage ?? latest.stage;
+    const source = summaryStage ? 'carrier_map' : latest.stage_source;
+    const country = clean(identity.Destination, 64).toUpperCase();
+    return { status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: source } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null,
+        ...(stage === 'delivered' && latest.time ? { delivered_at: latest.time } : {}),
+        ...(/^[A-Z]{2}$/.test(country) ? { destination_country: country } : {}), events: events.slice(0, 100) };
+}

package/dist/carriers/cne/statuses.json

@@ -1,4 +1,66 @@
 {
   "carrier": "cne",
-  "entries": []
+  "entries": [
+    {
+      "wording": "Parcel Infomation Received",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Picked Up by Courier",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment Loaded",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Departed CNE Facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Arrived at CNE Facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Inbound scan",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Shipment Processed",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "Sorting failed []",
+      "language": "en",
+      "stage": "exception",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "It was returned to customer's address by CNE",
+      "language": "en",
+      "stage": "returned",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "8",
+      "wording": "退件",
+      "language": "zh",
+      "stage": "returned",
+      "confirmedBy": "live"
+    }
+  ]
 }

package/dist/carriers/dpd-uk/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class DpdUkTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/dpd-uk/adapter.js

@@ -0,0 +1,58 @@
+import { CarrierError, NotFoundError, SchemaError, TransportError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isDpdUkReferenceAbsent, normalizeDpdUkNumber, parseDpdUkHistory, parseDpdUkReference, PROVIDER, validateDpdUkParcel } from './parser.js';
+const API = 'https://apis.track.dpd.co.uk/v1';
+export class DpdUkTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeDpdUkNumber(raw);
+        return runSteps({ carrier: 'dpd-uk', signal: context.signal, budgetMs: context.budgetMs ?? 15_000,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    const deadline = performance.now() + remainingMs;
+                    const read = async (path, reference = false) => {
+                        try {
+                            signal.throwIfAborted();
+                            const { bytes, response } = await fetchBounded(`${API}${path}`, { signal, headers: { Accept: 'application/json' } }, { provider: PROVIDER, timeoutMs: Math.max(1, Math.floor(deadline - performance.now())), maxBytes: 1_000_000,
+                                fetcher: this.options.fetcher, allowHttpStatuses: [404, 410] });
+                            let payload;
+                            try {
+                                payload = parseJsonBytes(bytes, PROVIDER);
+                            }
+                            catch {
+                                throw response.ok ? new SchemaError(PROVIDER) : new TransportError(PROVIDER, 'DPD UK tracking endpoint is unavailable');
+                            }
+                            if (!response.ok) {
+                                if (reference && response.status === 404 && isDpdUkReferenceAbsent(payload))
+                                    throw new NotFoundError(PROVIDER);
+                                throw new TransportError(PROVIDER, 'DPD UK tracking endpoint is unavailable');
+                            }
+                            return payload;
+                        }
+                        catch (error) {
+                            signal.throwIfAborted();
+                            // Request diagnostics and malformed bodies can contain an issued parcel
+                            // handle or personal details. Keep the classification, never its cause.
+                            if (error instanceof CarrierError)
+                                throw new CarrierError(error.kind, PROVIDER, `${PROVIDER} tracking failed (${error.kind})`, { status: error.status, retryAfterMs: error.retryAfterMs, reason: error.reason });
+                            throw new TransportError(PROVIDER);
+                        }
+                    };
+                    const query = new URLSearchParams({ origin: 'PRTK', postcode: '', referenceNumber: number });
+                    const code = parseDpdUkReference(await read(`/reference?${query}`, true), number);
+                    const parcelPath = `/parcels/${encodeURIComponent(code)}`;
+                    const detail = await read(parcelPath);
+                    validateDpdUkParcel(detail, number, code);
+                    const history = await read(`${parcelPath}/parcelevents`);
+                    return parseDpdUkHistory(detail, history, number, code);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new DpdUkTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'dpd-uk', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/dpd-uk/carrier.json

@@ -16,13 +16,15 @@
   "timezone": "Europe/London",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "dpd-uk",
+    "steps": [
+      "direct"
+    ],
+    "localClocks": true
   },
   "capabilities": [
     "history",
-    "location",
-    "eta"
+    "location"
   ],
   "portal": {
     "url": "https://track.dpd.co.uk/?reference={trackingNumber}",
@@ -33,8 +35,18 @@
       "location",
       "eta"
     ],
-    "scraped": [],
-    "discarded": [],
+    "scraped": [
+      "status",
+      "history",
+      "location"
+    ],
+    "discarded": [
+      "parcel_handle",
+      "merchant_reference",
+      "delivery_partner_reference",
+      "recipient_details",
+      "proof_of_delivery_images"
+    ],
     "unavailable": []
   },
   "links": [

package/dist/carriers/dpd-uk/numbers.json

@@ -1,5 +1,33 @@
 {
   "carrier": "dpd-uk",
-  "gap": "no public sample found yet",
-  "records": []
+  "records": [
+    {
+      "number": "15504366056765",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://uk.trustpilot.com/review/primepaint.co.uk?page=3"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": ["dpd", "dpd-fr", "relais-colis", "ciblex", "seur", "brt", "delhivery", "dpd-de", "dpd-uk", "xpressbees"]
+      },
+      "note": "Prime Paint's public reply identifies this as DPD UK. A numeric shape alone does not identify the service. Tracking numbers can be reused; current history need not belong to the original report."
+    },
+    {
+      "number": "15504366057635",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://uk.trustpilot.com/review/primepaint.co.uk?page=3"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": ["dpd", "dpd-fr", "relais-colis", "ciblex", "seur", "brt", "delhivery", "dpd-de", "dpd-uk", "xpressbees"]
+      },
+      "note": "Prime Paint's public reply identifies this as DPD UK. A numeric shape alone does not identify the service. Tracking numbers can be reused; current history need not belong to the original report."
+    }
+  ]
 }

package/dist/carriers/dpd-uk/parser.d.ts

@@ -0,0 +1,9 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "DPD UK";
+export declare function normalizeDpdUkNumber(raw: string): string;
+/** Resolve one exact parcel, keeping its issued code opaque and lookup-local. */
+export declare function parseDpdUkReference(payload: unknown, number: string): string;
+export declare function isDpdUkReferenceAbsent(payload: unknown): boolean;
+export declare function validateDpdUkParcel(payload: unknown, number: string, code: string): Record<string, unknown>;
+/** Events have no identity field; the adapter reads them under the exact validated detail handle. */
+export declare function parseDpdUkHistory(detailPayload: unknown, historyPayload: unknown, raw: string, code: string): CarrierResult;

package/dist/carriers/dpd-uk/parser.js

@@ -0,0 +1,127 @@
+import { DateTime } from 'luxon';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InvalidInputError, SchemaError } from '../../core/errors/index.js';
+import { classifyWording, languageStageStatus } from '../../core/status/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+export const PROVIDER = 'DPD UK';
+export function normalizeDpdUkNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!/^\d{14}$/.test(number))
+        throw new InvalidInputError(PROVIDER, 'DPD UK requires a fourteen-digit parcel number');
+    return number;
+}
+// The public client displays spaced digits followed by a printed check letter.
+function parcelNumber(value) {
+    if (typeof value !== 'string' || value.length > 64)
+        return null;
+    const match = /^(\d{14})[A-Z]?$/.exec(value.replace(/\s/g, '').toUpperCase());
+    return match?.[1] ?? null;
+}
+/** Resolve one exact parcel, keeping its issued code opaque and lookup-local. */
+export function parseDpdUkReference(payload, number) {
+    if (!isRecord(payload) || !Array.isArray(payload.data) || payload.data.length > 100)
+        throw new SchemaError(PROVIDER);
+    if (!payload.data.length)
+        throw new IndeterminateError(PROVIDER, 'DPD UK returned no matching parcel');
+    if (payload.data.length !== 1 || !isRecord(payload.data[0]) || parcelNumber(payload.data[0].parcelNumber) !== number) {
+        throw new SchemaError(PROVIDER, 'DPD UK returned a different or ambiguous parcel');
+    }
+    const code = payload.data[0].parcelCode;
+    if (typeof code !== 'string' || !/^[A-Za-z0-9*_-]{1,128}$/.test(code))
+        throw new SchemaError(PROVIDER, 'DPD UK returned an invalid parcel handle');
+    return code;
+}
+export function isDpdUkReferenceAbsent(payload) {
+    return isRecord(payload) && !Object.hasOwn(payload, 'data') && isRecord(payload.error)
+        && payload.error.statusCode === 404 && payload.error.error === 'Not Found'
+        && payload.error.message === 'Your reference number could not be found';
+}
+export function validateDpdUkParcel(payload, number, code) {
+    if (!isRecord(payload) || !isRecord(payload.data) || parcelNumber(payload.data.parcelNumber) !== number
+        || payload.data.parcelCode !== code)
+        throw new SchemaError(PROVIDER, 'DPD UK returned a different parcel');
+    return payload.data;
+}
+const VERIFIED_WORDING = {
+    'your parcel has been delivered': 'delivered',
+    'the parcel has been delivered': 'delivered',
+    'your parcel will be with you today': 'out_for_delivery',
+    'the parcel is on the vehicle for delivery': 'out_for_delivery',
+    'your parcel is at our depot': 'in_transit',
+    "we have your parcel and it's on its way to our depot": 'in_transit',
+    "we have your parcel and it's on its way to you": 'in_transit',
+    'we have x-rayed your parcel as part of our normal security procedures': 'in_transit',
+    "we've received your order details, but have not yet received your parcel": 'registered',
+};
+function classify(description) {
+    const wording = description.toLowerCase().replace(/[’‘]/g, "'").replace(/\s+/g, ' ').trim().replace(/[.!]+$/, '');
+    const stage = VERIFIED_WORDING[wording];
+    return stage ? { stage, source: 'carrier_map' } : classifyWording(description);
+}
+function publicDescription(value) {
+    const text = clean(value, 1000);
+    // A sender return is a shipment stage, rather than a recipient's identity.
+    if (/\bdelivered (?:back )?to (?:the )?(?:sender|shipper)\b/i.test(text))
+        return text;
+    return text.replace(/(\bdelivered)\s+(?:to\s+.+|and\s+signed\s+(?:for\s+)?by\s+.+|signed\s+(?:for\s+)?by\s+.+)$/i, '$1');
+}
+function clockFields(clock) {
+    const shape = /^(\d{4}-\d{2}-\d{2})[ T]((?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d)(Z|[+-]\d{2}:?\d{2})?$/.exec(clock);
+    if (!shape)
+        return { provider_time_text: clock };
+    const iso = `${shape[1]}T${shape[2]}${shape[3] ?? ''}`;
+    if (!DateTime.fromISO(iso, { zone: 'UTC', setZone: true }).isValid)
+        return { provider_time_text: clock };
+    if (!shape[3])
+        return { local_time: `${shape[1]}T${shape[2]}` };
+    const offset = /[+-](\d{2}):?(\d{2})$/.exec(iso);
+    if (offset && (Number(offset[1]) > 14 || Number(offset[2]) > 59 || (Number(offset[1]) === 14 && Number(offset[2]) !== 0))) {
+        return { provider_time_text: clock };
+    }
+    const instant = explicitOffsetTime(iso);
+    return instant ? { time: instant.iso } : { provider_time_text: clock };
+}
+/** Events have no identity field; the adapter reads them under the exact validated detail handle. */
+export function parseDpdUkHistory(detailPayload, historyPayload, raw, code) {
+    const number = normalizeDpdUkNumber(raw);
+    const detail = validateDpdUkParcel(detailPayload, number, code);
+    if (!isRecord(historyPayload) || !Array.isArray(historyPayload.data) || historyPayload.data.length > 1000)
+        throw new SchemaError(PROVIDER);
+    if (!historyPayload.data.length)
+        throw new IndeterminateError(PROVIDER, 'DPD UK returned no parcel history');
+    // The official page renders these rows newest first. Do not reorder uncertain clocks.
+    const events = historyPayload.data.map(row => {
+        if (!isRecord(row))
+            throw new SchemaError(PROVIDER);
+        if ((row.parcelNumber !== undefined && parcelNumber(row.parcelNumber) !== number)
+            || (row.parcelCode !== undefined && row.parcelCode !== code))
+            throw new SchemaError(PROVIDER, 'DPD UK returned a different scan identity');
+        const description = publicDescription(row.eventText);
+        const clock = clean(row.eventDate, 64);
+        if (!description || !clock || typeof row.eventDate !== 'string' || row.eventDate.length > 64)
+            throw new SchemaError(PROVIDER, 'DPD UK returned an incomplete scan');
+        const classification = classify(description);
+        const location = clean(row.eventLocation, 200);
+        return { description, ...clockFields(clock), ...(location ? { location } : {}),
+            ...(classification.source !== 'none' ? { stage: classification.stage, stage_source: classification.source } : {}) };
+    });
+    const seen = new Set();
+    const retained = events.filter(event => {
+        const key = JSON.stringify(event);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }).slice(0, 100);
+    const latest = retained[0];
+    const summary = publicDescription(detail.trackingStatusCurrent);
+    const summaryClassification = classify(summary);
+    const current = summary ? summaryClassification : classify(latest.description);
+    return { status: current.source !== 'none' ? languageStageStatus(current.stage) : 'unknown',
+        ...(current.source !== 'none' ? { current_stage: current.stage, current_stage_source: current.source } : {}),
+        last_status_text: summary || latest.description, last_update: latest.time ?? null,
+        ...(latest.local_time ? { last_update_local: latest.local_time } : {}),
+        ...(current.stage === 'delivered' && latest.stage === 'delivered' && latest.time ? { delivered_at: latest.time } : {}), events: retained };
+}

package/dist/carriers/evri-uk/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class EvriUkTracker {
+    private readonly options;
+    constructor(options?: {
+        executablePath?: string | null;
+        recorder?: StepRecorder;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/evri-uk/adapter.js

@@ -0,0 +1,80 @@
+import { carrierErrorKind, ChallengeError, IndeterminateError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { withLocalBrowser } from '../../core/transport/localBrowser.js';
+import { requestEvriUkInPage } from './browser.js';
+import { normalizeEvriUkNumber, parseEvriUk } from './parser.js';
+export class EvriUkTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizeEvriUkNumber(raw);
+        const budgetMs = context.budgetMs ?? 45_000;
+        if (!Number.isFinite(budgetMs) || budgetMs <= 0 || budgetMs > 60_000)
+            throw new TypeError('Evri UK budget must be between 1 and 60000 ms');
+        if (!this.options.executablePath)
+            throw new ChallengeError('Evri UK', 'Evri UK requires TRACKING_CHROMIUM_PATH');
+        return runSteps({ carrier: 'evri-uk', budgetMs, signal: context.signal, recorder: this.options.recorder ?? NOOP_RECORDER }, [{
+                id: 'browser', run: ({ signal, remainingMs: remaining }) => withLocalBrowser({ provider: 'Evri UK',
+                    executablePath: this.options.executablePath, signal, timeoutMs: Math.max(1, Math.floor(remaining)),
+                    args: ['--disable-blink-features=AutomationControlled'], }, async ({ browser, signal: session, remainingMs }) => {
+                    try {
+                        const platform = process.platform === 'darwin' ? 'Macintosh; Intel Mac OS X 10_15_7'
+                            : process.platform === 'win32' ? 'Windows NT 10.0; Win64; x64' : 'X11; Linux x86_64';
+                        const major = browser.version().split('.')[0];
+                        const userAgent = `Mozilla/5.0 (${platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`;
+                        const browserContext = await browser.newContext({ locale: 'en-GB', userAgent, acceptDownloads: false, serviceWorkers: 'block' });
+                        session.throwIfAborted();
+                        await browserContext.route('**/*', async (route) => {
+                            const url = new URL(route.request().url());
+                            const allowed = url.protocol === 'https:' && (['www.evri.com', 'api.evri.com', 'tracking.platform-apis.evri.com'].includes(url.hostname)
+                                || url.hostname.endsWith('.edge.sdk.awswaf.com'));
+                            await (allowed ? route.continue() : route.abort());
+                        });
+                        const page = await browserContext.newPage();
+                        const response = await page.goto('https://www.evri.com/track-a-parcel', { waitUntil: 'domcontentloaded', timeout: Math.min(15_000, remainingMs()) });
+                        session.throwIfAborted();
+                        if (!response)
+                            throw new TransportError('Evri UK', 'Evri UK tracking page is unavailable');
+                        if ([401, 403].includes(response.status()))
+                            throw new ChallengeError('Evri UK');
+                        if (response.status() !== 200)
+                            throw new UpstreamHttpError('Evri UK', response.status());
+                        await page.waitForFunction(() => typeof globalThis.AwsWafIntegration?.getToken === 'function', undefined, { timeout: Math.min(10_000, remainingMs()) });
+                        session.throwIfAborted();
+                        const reply = await page.evaluate(requestEvriUkInPage, { number, budgetMs: remainingMs() });
+                        session.throwIfAborted();
+                        if (reply.kind === 'ok')
+                            return parseEvriUk(reply.payload, number, reply.urn);
+                        if (reply.kind === 'http') {
+                            if ([401, 403, 405].includes(reply.status ?? 0))
+                                throw new ChallengeError('Evri UK');
+                            if (reply.status === 429)
+                                throw new RateLimitedError('Evri UK', reply.retryAfter && /^\d+$/.test(reply.retryAfter) ? Number(reply.retryAfter) * 1_000 : undefined);
+                            if ([404, 410].includes(reply.status ?? 0))
+                                throw new TransportError('Evri UK', 'Evri UK tracking endpoint is unavailable');
+                            throw new UpstreamHttpError('Evri UK', reply.status ?? 0);
+                        }
+                        if (['schema', 'identity', 'context'].includes(reply.kind))
+                            throw new SchemaError('Evri UK', 'Evri UK returned invalid tracking data');
+                        if (['indeterminate', 'scope'].includes(reply.kind))
+                            throw new IndeterminateError('Evri UK', 'Evri UK could not confirm a domestic parcel');
+                        throw new TransportError('Evri UK', 'Evri UK browser tracking failed');
+                    }
+                    catch (error) {
+                        session.throwIfAborted();
+                        if (carrierErrorKind(error))
+                            throw error;
+                        // Browser failures can include private tracking or issued URLs.
+                        throw new TransportError('Evri UK', 'Evri UK browser tracking failed');
+                    }
+                }),
+            }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new EvriUkTracker({ executablePath: environment.browserExecutablePath, recorder: environment.recorder });
+    return { id: 'evri-uk', recordsSteps: true, steps: ['browser'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/evri-uk/browser.d.ts

@@ -0,0 +1,56 @@
+/** Runs in the official page. No issued key or browser token leaves this context. */
+export declare function requestEvriUkInPage({ number, budgetMs }: {
+    number: string;
+    budgetMs: number;
+}): Promise<{
+    kind: "context";
+    phase?: undefined;
+    urn?: undefined;
+    payload?: undefined;
+} | {
+    kind: "indeterminate";
+    phase: string;
+    urn?: undefined;
+    payload?: undefined;
+} | {
+    kind: "scope";
+    phase: string;
+    urn?: undefined;
+    payload?: undefined;
+} | {
+    kind: "identity";
+    phase: string;
+    urn?: undefined;
+    payload?: undefined;
+} | {
+    kind: "ok";
+    urn: string;
+    payload: {
+        failures: never[];
+        results: {
+            uniqueId: string;
+            parcelIdentifiers: {
+                type: string;
+                value: string;
+            }[];
+            trackingEvents: {
+                dateTime: string;
+                trackingPoint: {
+                    trackingPointCode: string;
+                    description: string;
+                };
+                trackingStage: {
+                    trackingStageCode: string;
+                };
+            }[];
+        }[];
+    };
+    phase?: undefined;
+} | {
+    retryAfter?: string | undefined;
+    status?: number | undefined;
+    kind: "http" | "schema" | "transport";
+    phase: string;
+    urn?: undefined;
+    payload?: undefined;
+}>;