universal-parcel-scraper 0.12.0-main.336 → 0.13.0-main.337

package/README.md

@@ -13,7 +13,7 @@ The engine behind [Peek](https://peektracker.com) ([GitHub](https://github.com/p
 [![License: Apache-2.0](https://img.shields.io/badge/core-Apache--2.0-blue.svg)](LICENSE)
 
 <!-- GENERATED:summary -->
-**3,500+ carriers** through **96 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **98 dedicated adapters** and **5 universal fallbacks**
 
 <sub>119 catalog entries · 58 countries represented</sub>
 <!-- /GENERATED:summary -->
@@ -33,9 +33,9 @@ its own as a command, a Node library or an HTTP server.
 ## Benchmark
 
 <!-- GENERATED:coverage -->
-In a curated benchmark of 113 carriers, dedicated adapters return tracking history for **69**, rising to **82** with all fallbacks enabled. The best single aggregator returns 53.
+In a curated benchmark of 113 carriers, dedicated adapters return tracking history for **71**, rising to **84** with all fallbacks enabled. The best single aggregator returns 53.
 
-<img src="docs/assets/coverage.svg" alt="Carriers with tracking history: This project, all fallbacks enabled 82, This project, dedicated adapters alone 69, ParcelsApp 53, Postal Ninja 43, 17TRACK 40, Ship24 42, UPU 12." width="760">
+<img src="docs/assets/coverage.svg" alt="Carriers with tracking history: This project, all fallbacks enabled 84, This project, dedicated adapters alone 71, ParcelsApp 53, Postal Ninja 43, 17TRACK 40, Ship24 42, UPU 12." width="760">
 <!-- /GENERATED:coverage -->
 
 [Method and results per carrier](providers/COVERAGE.md)
@@ -149,7 +149,7 @@ createTracker({ providers: ['ParcelsApp', 'Ship24', '17TRACK', 'Postal Ninja', '
 <!-- GENERATED:stages -->
 <img src="docs/assets/stages.svg" alt="DHL: Die Sendung wurde in das Zustellfahrzeug geladen.; Mondial Relay: En cours de livraison; Correios Brazil: Objeto saiu para entrega ao destinatário; Correos Express: EN REPARTO; Yamato Transport: 配達中; La Poste / Colissimo: DISTOU. All are filed under out_for_delivery." width="760">
 
-The carrier folders record 1,779 such statuses, each filed under one stage.
+The carrier folders record 1,785 such statuses, each filed under one stage.
 <!-- /GENERATED:stages -->
 
 Wording nobody recorded yet goes through a classifier that reads seven European languages.

package/data/catalog.json

@@ -4172,7 +4172,8 @@
     "timezone": "Europe/London",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "dpd-uk",
+      "localClocks": true
     },
     "canaryUrl": "https://track.dpd.co.uk/",
     "trackingUrlTemplate": "https://track.dpd.co.uk/?reference={trackingNumber}",
@@ -4242,7 +4243,7 @@
     "timezone": "Europe/London",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "evri-uk"
     },
     "canaryUrl": "https://www.evri.com/track-a-parcel",
     "trackingUrlTemplate": "https://www.evri.com/track/parcel/{trackingNumber}/details",

package/data/coverage-summary.json

@@ -1,11 +1,11 @@
 {
   "catalog": 119,
-  "activeAdapters": 96,
+  "activeAdapters": 98,
   "countries": 58,
   "referenceCarriers": 113,
   "comparison": {
-    "combined": 82,
-    "direct": 69,
+    "combined": 84,
+    "direct": 71,
     "providers": {
       "ParcelsApp": 53,
       "Postal Ninja": 43,

package/data/detection-golden.json

@@ -1380,6 +1380,54 @@
       "colis-prive"
     ]
   },
+  {
+    "input": "15504366056765",
+    "carrier": "unknown",
+    "confidence": "low",
+    "candidates": [
+      "dpd",
+      "dpd-fr",
+      "relais-colis",
+      "ciblex",
+      "seur",
+      "brt",
+      "delhivery",
+      "dpd-de",
+      "dpd-uk",
+      "xpressbees"
+    ],
+    "asked": [
+      "dpd",
+      "seur",
+      "brt",
+      "relais-colis",
+      "ciblex"
+    ]
+  },
+  {
+    "input": "15504366057635",
+    "carrier": "unknown",
+    "confidence": "low",
+    "candidates": [
+      "dpd",
+      "dpd-fr",
+      "relais-colis",
+      "ciblex",
+      "seur",
+      "brt",
+      "delhivery",
+      "dpd-de",
+      "dpd-uk",
+      "xpressbees"
+    ],
+    "asked": [
+      "dpd",
+      "seur",
+      "brt",
+      "relais-colis",
+      "ciblex"
+    ]
+  },
   {
     "input": "1595193512495",
     "carrier": "unknown",

package/dist/browser/scraper.js

@@ -3213,7 +3213,8 @@ var ce = {
 		timezone: "Europe/London",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "dpd-uk",
+			localClocks: !0
 		},
 		canaryUrl: "https://track.dpd.co.uk/",
 		trackingUrlTemplate: "https://track.dpd.co.uk/?reference={trackingNumber}",
@@ -3261,7 +3262,7 @@ var ce = {
 		timezone: "Europe/London",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "evri-uk"
 		},
 		canaryUrl: "https://www.evri.com/track-a-parcel",
 		trackingUrlTemplate: "https://www.evri.com/track/parcel/{trackingNumber}/details",
@@ -8289,7 +8290,7 @@ var gs = { carriers: [
 			"Postal Ninja": 4,
 			UPU: "no_history"
 		} }, {
-			note: "Alternate public reference returned eight identity-bound full-history scans in an interactive official session; fresh automated browser retrieval remains denied: https://www.reddit.com/r/royalmail/comments/1wh27pw/cant_track_my_shipment/",
+			note: "Alternate public reference returned eight identity-bound full-history scans in an interactive official session. Fresh automated Chromium obtained the matching microsummary, but its separate events request failed; automated full history remains unverified: https://www.reddit.com/r/royalmail/comments/1wh27pw/cant_track_my_shipment/",
 			results: {}
 		}]
 	},
@@ -9713,10 +9714,10 @@ var gs = { carriers: [
 	},
 	{
 		carrier: "dpd-uk",
-		direct: "No adapter",
-		sample: "Blocked",
+		direct: "Yes (UK parcel numbers)",
+		sample: "✓ 7",
 		references: [{
-			note: "UK reference-plus-postcode flow requires a challenge and session before retrieval.",
+			note: "Public UK parcel references returned seven and eight history scans through the current anonymous empty-postcode lookup; unqualified scan clocks remain local: https://uk.trustpilot.com/review/primepaint.co.uk?page=3. Order and collection references behind the postcode form are outside the adapter scope.",
 			results: {
 				Ship24: "unverified",
 				ParcelsApp: "unverified",
@@ -9728,10 +9729,10 @@ var gs = { carriers: [
 	},
 	{
 		carrier: "evri-uk",
-		direct: "No adapter",
-		sample: "Blocked",
+		direct: "Yes (local Chromium)",
+		sample: "✓ 6",
 		references: [{
-			note: "The official interactive navigation flow obtained rotating keys and six dated parcel scans. Fresh automated browser sessions are denied the keys: https://www.trustpilot.com/review/printerval.co.uk",
+			note: "Public domestic reference returned six identity-bound, offset-dated history scans in fresh automated local Chromium. The current anonymous flow obtains rotating keys in the browser and requires no postcode: https://www.trustpilot.com/review/printerval.co.uk",
 			results: {
 				Ship24: "unverified",
 				ParcelsApp: "unverified",
@@ -9866,7 +9867,7 @@ var gs = { carriers: [
 		direct: "No adapter",
 		sample: "Blocked",
 		references: [{
-			note: "The current corporate tracking form posts to the public tracking service, which returns access denied. This is not evidence of parcel absence.",
+			note: "Sagawa has suspended public shipment inquiry and its carrier inquiry API; fresh anonymous history retrieval is unavailable: https://www2.sagawa-exp.co.jp/information/detail/425/",
 			results: {
 				Ship24: "unverified",
 				ParcelsApp: "unverified",

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;
+}>;

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

@@ -0,0 +1,137 @@
+/** Runs in the official page. No issued key or browser token leaves this context. */
+export async function requestEvriUkInPage({ number, budgetMs }) {
+    const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+    const sdk = globalThis.AwsWafIntegration;
+    if (location.origin !== 'https://www.evri.com' || !/^\/track-a-parcel\/?$/.test(location.pathname)
+        || !/^[A-Z0-9]{16}$/.test(number) || !sdk || !(budgetMs > 0))
+        return { kind: 'context' };
+    const signal = AbortSignal.timeout(Math.max(1, Math.floor(Math.min(budgetMs, 20_000))));
+    let total = 0;
+    let phase = 'keys';
+    const failure = (kind, status, retryAfter) => Object.assign(new Error('Evri UK request failed'), { kind, phase, status, retryAfter });
+    const json = async (response, maxBytes) => {
+        if (response.status !== 200)
+            throw failure('http', response.status, response.headers.get('retry-after'));
+        if (!(response.headers.get('content-type') ?? '').includes('application/json')
+            || Number(response.headers.get('content-length') ?? 0) > maxBytes || !response.body)
+            throw failure('schema');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let text = '';
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                total += value.byteLength;
+                if (size > maxBytes || total > 3_000_000) {
+                    await reader.cancel();
+                    throw failure('schema');
+                }
+                text += decoder.decode(value, { stream: true });
+            }
+            text += decoder.decode();
+        }
+        finally {
+            reader.releaseLock();
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw failure('schema');
+        }
+    };
+    try {
+        await Promise.race([sdk.getToken(), new Promise((_, reject) => {
+                signal.addEventListener('abort', () => reject(failure('transport')), { once: true });
+            })]);
+        const keyData = await json(await sdk.fetch('/protected/keys.json', { method: 'GET', signal,
+            headers: { 'Content-Type': 'application/json' } }), 100_000);
+        if (!record(keyData) || !record(keyData.keys))
+            return { kind: 'schema', phase };
+        const customerKey = keyData.keys['spa-customer-track-key'];
+        const trackKey = keyData.keys['spa-track-key'];
+        if (typeof customerKey !== 'string' || !customerKey || typeof trackKey !== 'string' || !trackKey)
+            return { kind: 'schema', phase };
+        phase = 'search';
+        const data = await json(await fetch(`https://api.evri.com/customer-tracking/v1/search/${number}`, {
+            signal, redirect: 'error', headers: { apiKey: customerKey, 'Content-Type': 'application/json' },
+        }), 200_000);
+        if (!record(data) || !Array.isArray(data.parcels) || data.parcels.length > 50)
+            return { kind: 'schema', phase };
+        if (data.parcels.length !== 1)
+            return { kind: 'indeterminate', phase };
+        const parcel = data.parcels[0];
+        if (!record(parcel) || !Array.isArray(parcel.identifiers) || !record(parcel.brand))
+            return { kind: 'schema', phase };
+        if (parcel.brand.name !== 'EVRI' || parcel.externalRedirectUrl)
+            return { kind: 'scope', phase };
+        const parcelIds = parcel.identifiers.filter(id => record(id) && id.type === 'PARCEL_ID');
+        const barcodes = parcel.identifiers.filter(id => record(id) && id.type === 'BARCODE');
+        if (parcelIds.length !== 1 || barcodes.length !== 1 || !record(parcelIds[0]) || !record(barcodes[0])
+            || typeof parcelIds[0].value !== 'string' || !/^\d{1,30}$/.test(parcelIds[0].value) || barcodes[0].value !== number) {
+            return { kind: 'identity', phase };
+        }
+        // The current application constructs this URN from the search identifiers
+        // and the lookup's UTC calendar day, rather than accepting a reused handle.
+        const urn = `urn:parcel_id:barcode:date:${parcelIds[0].value}:${number}:${new Date().toISOString().slice(0, 10)}`;
+        phase = 'history';
+        const endpoint = new URL('https://tracking.platform-apis.evri.com/v1/parcels');
+        endpoint.searchParams.set('uniqueIds', urn);
+        const history = await json(await fetch(endpoint.href, { signal, redirect: 'error',
+            headers: { apiKey: trackKey, 'Content-Type': 'application/json' } }), 2_000_000);
+        if (!record(history) || !Array.isArray(history.results) || !Array.isArray(history.failures))
+            return { kind: 'schema', phase };
+        if (history.failures.length || history.results.length === 0)
+            return { kind: 'indeterminate', phase };
+        if (history.results.length !== 1 || !record(history.results[0]))
+            return { kind: 'schema', phase };
+        const result = history.results[0];
+        if (!Array.isArray(result.parcelIdentifiers) || result.parcelIdentifiers.length > 50
+            || !result.parcelIdentifiers.every(id => record(id) && typeof id.type === 'string' && typeof id.value === 'string')) {
+            return { kind: 'identity', phase };
+        }
+        const returnedBarcodes = result.parcelIdentifiers.filter(id => record(id) && id.type === 'BARCODE');
+        if (!returnedBarcodes.length || returnedBarcodes.some(id => !record(id) || id.value !== number)
+            || result.uniqueId !== urn)
+            return { kind: 'identity', phase };
+        if (!Array.isArray(result.trackingEvents) || result.trackingEvents.length > 500) {
+            return { kind: 'schema', phase };
+        }
+        const scalar = (value, limit) => typeof value === 'string' && value.length <= limit && value.trim().length > 0;
+        const events = [];
+        for (const event of result.trackingEvents) {
+            if (!record(event) || !record(event.trackingPoint) || !record(event.trackingStage)
+                || !scalar(event.dateTime, 64) || !scalar(event.trackingPoint.trackingPointCode, 64)
+                || !scalar(event.trackingPoint.description, 1000) || !scalar(event.trackingStage.trackingStageCode, 64)
+                || !/^[A-Za-z0-9_-]{1,64}$/.test(event.trackingPoint.trackingPointCode)
+                || !/^[A-Za-z0-9_-]{1,64}$/.test(event.trackingStage.trackingStageCode)) {
+                return { kind: 'schema', phase };
+            }
+            const stageCode = event.trackingStage.trackingStageCode.trim();
+            const description = event.trackingPoint.description;
+            const safeDescription = stageCode === '5_COURIER' ? 'Delivered'
+                : /\b(?:delivered (?:to|by)|signed (?:for )?by)\b/i.test(description) ? 'Delivery update' : description;
+            events.push({ dateTime: event.dateTime,
+                trackingPoint: { trackingPointCode: event.trackingPoint.trackingPointCode, description: safeDescription },
+                trackingStage: { trackingStageCode: stageCode } });
+        }
+        // Copy only validated identity and scan scalars. Ownership, contacts,
+        // photos, map links, GPS, instructions and issued credentials stay here.
+        return { kind: 'ok', urn, payload: { failures: [], results: [{
+                        uniqueId: urn, parcelIdentifiers: returnedBarcodes.map(() => ({ type: 'BARCODE', value: number })),
+                        trackingEvents: events,
+                    }] } };
+    }
+    catch (error) {
+        if (record(error) && ['http', 'schema', 'transport'].includes(String(error.kind))) {
+            return { kind: error.kind, phase,
+                ...(typeof error.status === 'number' ? { status: error.status } : {}),
+                ...(typeof error.retryAfter === 'string' ? { retryAfter: error.retryAfter.slice(0, 100) } : {}) };
+        }
+        return { kind: 'transport', phase };
+    }
+}

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

@@ -18,13 +18,13 @@
   "timezone": "Europe/London",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "evri-uk",
+    "steps": [
+      "browser"
+    ]
   },
   "capabilities": [
-    "history",
-    "location",
-    "eta"
+    "history"
   ],
   "portal": {
     "url": "https://www.evri.com/track/parcel/{trackingNumber}/details",
@@ -35,9 +35,22 @@
       "eta",
       "proof_of_delivery"
     ],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "scraped": [
+      "status",
+      "history"
+    ],
+    "discarded": [
+      "recipient_details",
+      "address",
+      "proof_of_delivery",
+      "gps",
+      "sender_details",
+      "issued_credentials"
+    ],
+    "unavailable": [
+      "location",
+      "eta"
+    ]
   },
   "links": [
     {

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

@@ -0,0 +1,5 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeEvriUkNumber(raw: string): string;
+export declare function evriUkTrackingUrl(raw: string): string;
+/** The redacted anonymous feed contains scans; ownership fields are unnecessary. */
+export declare function parseEvriUk(payload: unknown, raw: string, expectedUrn?: string): CarrierResult;

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

@@ -0,0 +1,89 @@
+import { IndeterminateError, InvalidInputError, SchemaError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { cleanScalar } from '../../core/transport/text.js';
+import { isRecord } from '../../core/types.js';
+const STAGES = new Map([
+    ['1', 'registered'], ['2', 'in_transit'], ['3', 'in_transit'],
+    ['4_COURIER', 'out_for_delivery'], ['5_COURIER', 'delivered'],
+]);
+export function normalizeEvriUkNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s-]/g, '');
+    if (!/^[A-Z0-9]{16}$/.test(number))
+        throw new InvalidInputError('Evri UK', 'Evri UK requires a 16-character parcel barcode');
+    return number;
+}
+export function evriUkTrackingUrl(raw) {
+    return `https://www.evri.com/track/parcel/${normalizeEvriUkNumber(raw)}/details`;
+}
+function scanTime(raw) {
+    const text = cleanScalar(raw, 64);
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-](?:(?:0\d|1[0-3]):?[0-5]\d|14:?00))$/i.test(text)
+        ? explicitOffsetTime(text) : null;
+}
+/** The redacted anonymous feed contains scans; ownership fields are unnecessary. */
+export function parseEvriUk(payload, raw, expectedUrn) {
+    const number = normalizeEvriUkNumber(raw);
+    if (!isRecord(payload) || !Array.isArray(payload.results) || !Array.isArray(payload.failures)) {
+        throw new SchemaError('Evri UK', 'Evri UK returned invalid parcel history');
+    }
+    if (payload.failures.length || payload.results.length === 0)
+        throw new IndeterminateError('Evri UK', 'Evri UK could not confirm parcel history');
+    if (payload.results.length !== 1 || !isRecord(payload.results[0]))
+        throw new SchemaError('Evri UK', 'Evri UK returned ambiguous parcel history');
+    const parcel = payload.results[0];
+    const identifiers = parcel.parcelIdentifiers;
+    if (!Array.isArray(identifiers) || identifiers.length > 50
+        || !identifiers.every(id => isRecord(id) && typeof id.type === 'string' && typeof id.value === 'string')) {
+        throw new SchemaError('Evri UK', 'Evri UK did not return the requested parcel');
+    }
+    const barcodes = identifiers.filter(id => isRecord(id) && id.type === 'BARCODE');
+    if (!barcodes.length || barcodes.some(id => !isRecord(id) || id.value !== number)
+        || (expectedUrn !== undefined && parcel.uniqueId !== expectedUrn)) {
+        throw new SchemaError('Evri UK', 'Evri UK did not return the requested parcel');
+    }
+    if (!Array.isArray(parcel.trackingEvents) || parcel.trackingEvents.length > 500)
+        throw new SchemaError('Evri UK', 'Evri UK returned invalid tracking events');
+    if (!parcel.trackingEvents.length)
+        throw new IndeterminateError('Evri UK', 'Evri UK returned no parcel activity');
+    const events = [];
+    const seen = new Set();
+    for (const rawEvent of parcel.trackingEvents) {
+        if (!isRecord(rawEvent) || !isRecord(rawEvent.trackingPoint) || !isRecord(rawEvent.trackingStage)) {
+            throw new SchemaError('Evri UK', 'Evri UK returned invalid tracking events');
+        }
+        const description = cleanScalar(rawEvent.trackingPoint.description);
+        const code = cleanScalar(rawEvent.trackingPoint.trackingPointCode, 64);
+        const stageCode = cleanScalar(rawEvent.trackingStage.trackingStageCode, 64);
+        if (!description || !code || !stageCode)
+            throw new SchemaError('Evri UK', 'Evri UK returned invalid tracking events');
+        const stage = STAGES.get(stageCode);
+        const privateDeliveryProse = /\b(?:delivered (?:to|by)|signed (?:for )?by)\b/i.test(description);
+        const time = scanTime(rawEvent.dateTime);
+        const clock = cleanScalar(rawEvent.dateTime, 64);
+        const event = {
+            ...(time ? { time: time.iso } : clock ? { provider_time_text: clock } : {}),
+            description: stage === 'delivered' ? 'Delivered' : privateDeliveryProse ? 'Delivery update' : description,
+            ...(stage ? { stage, stage_source: 'carrier_map' } : {}),
+            provider_code: code,
+            provider_stage_code: stageCode,
+        };
+        const identity = JSON.stringify([time?.iso ?? clock, code, description]);
+        if (!seen.has(identity)) {
+            seen.add(identity);
+            events.push(event);
+        }
+    }
+    if (!events.some(event => event.time))
+        throw new IndeterminateError('Evri UK', 'Evri UK returned no dated parcel activity');
+    if (events.every(event => event.time))
+        events.sort((a, b) => Date.parse(b.time) - Date.parse(a.time));
+    const newest = events[0];
+    const stage = newest.stage;
+    const status = stage === 'registered' ? 'pending'
+        : stage === 'delivered' || stage === 'out_for_delivery' || stage === 'in_transit' ? stage : 'unknown';
+    return {
+        status, ...(stage ? { current_stage: stage } : {}), last_status_text: newest.description ?? null,
+        last_update: newest.time ?? null, events: events.slice(0, 100),
+        tracking_url: evriUkTrackingUrl(number), tracking_source: 'structured-web-response',
+    };
+}

package/dist/carriers/evri-uk/statuses.json

@@ -1,4 +1,11 @@
 {
   "carrier": "evri-uk",
-  "entries": []
+  "entries": [
+    { "code": "EXPECTED", "language": "en", "stage": "registered", "confirmedBy": "live" },
+    { "code": "PROCESSING_HUB", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "LOCAL_DEPOT", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "COURIER_DELIVERY", "language": "en", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "DELIVERY_1900_2100", "language": "en", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "LEFT_GARAGE", "language": "en", "stage": "delivered", "confirmedBy": "live" }
+  ]
 }

package/dist/data/catalog.json

@@ -4172,7 +4172,8 @@
         "timezone": "Europe/London",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "dpd-uk",
+            "localClocks": true
         },
         "canaryUrl": "https://track.dpd.co.uk/",
         "trackingUrlTemplate": "https://track.dpd.co.uk/?reference={trackingNumber}",
@@ -4242,7 +4243,7 @@
         "timezone": "Europe/London",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "evri-uk"
         },
         "canaryUrl": "https://www.evri.com/track-a-parcel",
         "trackingUrlTemplate": "https://www.evri.com/track/parcel/{trackingNumber}/details",

package/dist/generated/catalog.d.ts

@@ -2805,7 +2805,8 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "Europe/London";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "universal";
+            readonly adapter: "dpd-uk";
+            readonly localClocks: true;
         };
         readonly canaryUrl: "https://track.dpd.co.uk/";
         readonly trackingUrlTemplate: "https://track.dpd.co.uk/?reference={trackingNumber}";
@@ -2849,7 +2850,7 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "Europe/London";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "universal";
+            readonly adapter: "evri-uk";
         };
         readonly canaryUrl: "https://www.evri.com/track-a-parcel";
         readonly trackingUrlTemplate: "https://www.evri.com/track/parcel/{trackingNumber}/details";

package/dist/generated/catalog.js

@@ -4173,7 +4173,8 @@ export const CARRIER_CATALOG = {
         "timezone": "Europe/London",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "dpd-uk",
+            "localClocks": true
         },
         "canaryUrl": "https://track.dpd.co.uk/",
         "trackingUrlTemplate": "https://track.dpd.co.uk/?reference={trackingNumber}",
@@ -4243,7 +4244,7 @@ export const CARRIER_CATALOG = {
         "timezone": "Europe/London",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "evri-uk"
         },
         "canaryUrl": "https://www.evri.com/track-a-parcel",
         "trackingUrlTemplate": "https://www.evri.com/track/parcel/{trackingNumber}/details",

package/dist/generated/registry.js

@@ -30,12 +30,14 @@ import { adapter as dhlExpress } from '../carriers/dhl-express/adapter.js';
 import { adapter as dpd } from '../carriers/dpd/adapter.js';
 import { adapter as dpdDe } from '../carriers/dpd-de/adapter.js';
 import { adapter as dpdFr } from '../carriers/dpd-fr/adapter.js';
+import { adapter as dpdUk } from '../carriers/dpd-uk/adapter.js';
 import { adapter as dtdc } from '../carriers/dtdc/adapter.js';
 import { adapter as ecoscooting } from '../carriers/ecoscooting/adapter.js';
 import { adapter as ekart } from '../carriers/ekart/adapter.js';
 import { adapter as ems } from '../carriers/ems/adapter.js';
 import { adapter as estafeta } from '../carriers/estafeta/adapter.js';
 import { adapter as evri } from '../carriers/evri/adapter.js';
+import { adapter as evriUk } from '../carriers/evri-uk/adapter.js';
 import { adapter as fedex } from '../carriers/fedex/adapter.js';
 import { adapter as fourPx } from '../carriers/four-px/adapter.js';
 import { adapter as geodis } from '../carriers/geodis/adapter.js';
@@ -129,12 +131,14 @@ export const REGISTRY = {
         "dpd": dpd,
         "dpd-de": dpdDe,
         "dpd-fr": dpdFr,
+        "dpd-uk": dpdUk,
         "dtdc": dtdc,
         "ecoscooting": ecoscooting,
         "ekart": ekart,
         "ems": ems,
         "estafeta": estafeta,
         "evri": evri,
+        "evri-uk": evriUk,
         "fedex": fedex,
         "four-px": fourPx,
         "geodis": geodis,
@@ -233,14 +237,14 @@ export const REGISTRY = {
         "dpd": "dpd",
         "dpd-de": "dpd-de",
         "dpd-fr": "dpd-fr",
-        "dpd-uk": "universal",
+        "dpd-uk": "dpd-uk",
         "dtdc": "dtdc",
         "ecoscooting": "ecoscooting",
         "ekart": "ekart",
         "ems": "ems",
         "estafeta": "estafeta",
         "evri": "evri",
-        "evri-uk": "universal",
+        "evri-uk": "evri-uk",
         "fedex": "fedex",
         "four-px": "four-px",
         "geodis": "geodis",

package/dist/providers/coverage.json

@@ -152,7 +152,7 @@
           }
         },
         {
-          "note": "Alternate public reference returned eight identity-bound full-history scans in an interactive official session; fresh automated browser retrieval remains denied: https://www.reddit.com/r/royalmail/comments/1wh27pw/cant_track_my_shipment/",
+          "note": "Alternate public reference returned eight identity-bound full-history scans in an interactive official session. Fresh automated Chromium obtained the matching microsummary, but its separate events request failed; automated full history remains unverified: https://www.reddit.com/r/royalmail/comments/1wh27pw/cant_track_my_shipment/",
           "results": {}
         }
       ]
@@ -1916,11 +1916,11 @@
     },
     {
       "carrier": "dpd-uk",
-      "direct": "No adapter",
-      "sample": "Blocked",
+      "direct": "Yes (UK parcel numbers)",
+      "sample": "\u2713 7",
       "references": [
         {
-          "note": "UK reference-plus-postcode flow requires a challenge and session before retrieval.",
+          "note": "Public UK parcel references returned seven and eight history scans through the current anonymous empty-postcode lookup; unqualified scan clocks remain local: https://uk.trustpilot.com/review/primepaint.co.uk?page=3. Order and collection references behind the postcode form are outside the adapter scope.",
           "results": {
             "Ship24": "unverified",
             "ParcelsApp": "unverified",
@@ -1933,11 +1933,11 @@
     },
     {
       "carrier": "evri-uk",
-      "direct": "No adapter",
-      "sample": "Blocked",
+      "direct": "Yes (local Chromium)",
+      "sample": "\u2713 6",
       "references": [
         {
-          "note": "The official interactive navigation flow obtained rotating keys and six dated parcel scans. Fresh automated browser sessions are denied the keys: https://www.trustpilot.com/review/printerval.co.uk",
+          "note": "Public domestic reference returned six identity-bound, offset-dated history scans in fresh automated local Chromium. The current anonymous flow obtains rotating keys in the browser and requires no postcode: https://www.trustpilot.com/review/printerval.co.uk",
           "results": {
             "Ship24": "unverified",
             "ParcelsApp": "unverified",
@@ -2090,7 +2090,7 @@
       "sample": "Blocked",
       "references": [
         {
-          "note": "The current corporate tracking form posts to the public tracking service, which returns access denied. This is not evidence of parcel absence.",
+          "note": "Sagawa has suspended public shipment inquiry and its carrier inquiry API; fresh anonymous history retrieval is unavailable: https://www2.sagawa-exp.co.jp/information/detail/425/",
           "results": {
             "Ship24": "unverified",
             "ParcelsApp": "unverified",

package/dist/server/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Universal Parcel Scraper",
-    "version": "0.12.0"
+    "version": "0.13.0"
   },
   "paths": {
     "/health": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-parcel-scraper",
-  "version": "0.12.0-main.336",
+  "version": "0.13.0-main.337",
   "description": "Self-hosted parcel tracking: carrier detection, dedicated scrapers and optional universal providers.",
   "type": "module",
   "license": "Apache-2.0",