universal-parcel-scraper 0.43.0 → 0.44.0-main.411

package/dist/carriers/intl-post/numbers.json

@@ -24,6 +24,24 @@
         "confidence": "high"
       },
       "note": "Made-up number that follows the published format."
+    },
+    {
+      "number": "RR123456785TS",
+      "role": "negative",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-10-08",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "chronopost"
+        ],
+        "not": [
+          "intl-post"
+        ]
+      },
+      "note": "Invented number whose S10 check digit passes but whose TS suffix is a Chronopost code rather than an issuing country, so it is not international mail."
     }
   ]
 }

package/dist/carriers/la-poste/carrier.json

@@ -96,7 +96,7 @@
     },
     {
       "id": "la-poste-3",
-      "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
+      "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
       "confidence": "high",
       "checksum": "s10"
     }

package/dist/carriers/paack/adapter.d.ts

@@ -3,8 +3,8 @@ import type { CarrierResult } from '../../core/result/index.js';
 export declare function normalizePaackTrackingNumber(raw: string): string;
 export declare function normalizePaackPostcode(raw: string): string;
 export declare function paackTrackingUrl(rawTrackingNumber: string, rawPostcode: string): string;
-export declare function parsePaackTrackingResponse(payload: unknown, rawTrackingNumber: string): CarrierResult;
-export declare function parsePaackTrackingHtml(html: string, rawTrackingNumber: string): CarrierResult;
+export declare function parsePaackTrackingResponse(payload: unknown, rawPostcode: string): CarrierResult;
+export declare function parsePaackTrackingHtml(html: string, rawPostcode: string): CarrierResult;
 export interface PaackTrackerOptions {
     timeoutMs?: number;
     /** Test seam; production uses the global fetch. */

package/dist/carriers/paack/adapter.js

@@ -5,17 +5,21 @@
  * number and the delivery postcode returns server-rendered HTML whose
  * `window.__remixContext` already holds the loader response for the tracking
  * route. Reading that embedded payload avoids a second, undocumented API call
- * and gives the same data the page itself renders. The order number the
- * response echoes is verified before anything else is read.
+ * and gives the same data the page itself renders.
  *
- * A wrong number or postcode is answered with a redirect back to the form, or
- * with an explicit "order not found" message; both become a clean not-found.
+ * Paack answers the number and postcode as a pair: a wrong pair is redirected
+ * back to the form with `err=true`, or answered with an explicit "order not
+ * found" message, and both become a clean not-found. A tracking page is
+ * therefore the order for that pair. It does not echo the number when that is
+ * a label barcode (`external_id` is then the retailer's own reference), but it
+ * does echo the delivery postcode, which must agree with the requested one.
  *
  * Privacy: the loader payload carries the retailer, the recipient's name,
  * e-mail, phone and address, and per-event `variables` that repeat them.
  * `parse()` copies nothing from those objects: each event is rebuilt from its
  * timestamp, our own description and the mapped stage, and the only order-level
- * fields read are the echoed identifier and the delivery window.
+ * fields read are the delivery postcode, compared and never copied, and the
+ * delivery window.
  */
 import { load } from 'cheerio';
 import { lookupBudget } from '../../core/adapter/index.js';
@@ -27,6 +31,8 @@ const TRACKING_ENDPOINT = 'https://mydeliveries.paack.app/tracking/order';
 const DEFAULT_TIMEOUT_MS = 15_000;
 const MAX_RESPONSE_BYTES = 2_000_000;
 const MAX_EVENTS = 100;
+const MAX_REDIRECTS = 1;
+const PAACK_HOST = /(?:^|\.)paack\.(?:app|co)$/;
 const NOT_FOUND_PATTERN = /order not found|incorrect order number|commande introuvable|pedido no encontrado/i;
 const NOT_FOUND_PAGE_PATTERN = /order not found|incorrect order number or postal code|commande introuvable|pedido no encontrado/i;
 /**
@@ -122,16 +128,49 @@ export function normalizePaackPostcode(raw) {
     }
     return value.replace(/\s+/g, '');
 }
-export function paackTrackingUrl(rawTrackingNumber, rawPostcode) {
-    const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
-    const postcode = normalizePaackPostcode(rawPostcode);
-    const url = new URL(TRACKING_ENDPOINT);
+function trackingOrderUrl(base, trackingNumber, postcode) {
+    const url = new URL(base);
     url.searchParams.set('tracking_number', trackingNumber);
     url.searchParams.set('postal_code', postcode);
     return url.toString();
 }
-export function parsePaackTrackingResponse(payload, rawTrackingNumber) {
-    const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
+export function paackTrackingUrl(rawTrackingNumber, rawPostcode) {
+    return trackingOrderUrl(TRACKING_ENDPOINT, normalizePaackTrackingNumber(rawTrackingNumber), normalizePaackPostcode(rawPostcode));
+}
+/**
+ * Where a redirect from the lookup leads. `err=true` is Paack's answer to a
+ * wrong pair. The same lookup on another Paack host is followed: the page is
+ * moving from mydeliveries.paack.app to paack.co, and the old host forwards
+ * some lookups there before checking the postcode. Anything else proves
+ * nothing about the parcel.
+ */
+function redirectTarget(location, from, trackingNumber, postcode) {
+    if (!location)
+        return null;
+    let target;
+    try {
+        target = new URL(location, from);
+    }
+    catch {
+        return null;
+    }
+    if (target.protocol !== 'https:' || !PAACK_HOST.test(target.hostname))
+        return null;
+    if (target.searchParams.get('err') === 'true')
+        return { notFound: true };
+    const echoes = (name, value) => ((target.searchParams.get(name) ?? '').toLocaleUpperCase('en-US').replace(/\s/g, '') === value);
+    if (!target.pathname.endsWith('/tracking/order')
+        || !echoes('tracking_number', trackingNumber)
+        || !echoes('postal_code', postcode))
+        return null;
+    return { url: trackingOrderUrl(`${target.origin}${target.pathname}`, trackingNumber, postcode) };
+}
+/** Letters and digits only, so "SW1A 1AA" and "4445-027" compare by content. */
+function postcodeKey(value) {
+    return value.toLocaleUpperCase('en-US').replace(/[^A-Z0-9]/g, '');
+}
+export function parsePaackTrackingResponse(payload, rawPostcode) {
+    const postcode = normalizePaackPostcode(rawPostcode);
     if (NOT_FOUND_PATTERN.test(errorText(payload)))
         throw new NotFoundError('Paack');
     const route = routeData(payload);
@@ -140,17 +179,10 @@ export function parsePaackTrackingResponse(payload, rawTrackingNumber) {
     const order = route.orderTrackData;
     if (!isRecord(order))
         throw new SchemaError('Paack', 'Paack returned incomplete tracking details');
-    if (typeof order.external_id !== 'string')
-        throw new SchemaError('Paack', 'Paack returned an invalid shipment number');
-    let responseNumber;
-    try {
-        responseNumber = normalizePaackTrackingNumber(order.external_id);
-    }
-    catch (cause) {
-        // The echoed id is the provider's value, not the caller's input.
-        throw new SchemaError('Paack', 'Paack returned an invalid shipment number', { cause });
-    }
-    if (responseNumber !== trackingNumber) {
+    // The number is not echoed when it is a label barcode; the postcode is.
+    const address = isRecord(order.delivery_address) ? order.delivery_address : null;
+    const echoedPostcode = typeof address?.post_code === 'string' ? postcodeKey(address.post_code) : '';
+    if (echoedPostcode && echoedPostcode !== postcodeKey(postcode)) {
         throw new SchemaError('Paack', 'Paack returned a different shipment');
     }
     const rawEvents = Array.isArray(route.eventList) ? route.eventList : [];
@@ -203,13 +235,13 @@ export function parsePaackTrackingResponse(payload, rawTrackingNumber) {
         events,
     };
 }
-export function parsePaackTrackingHtml(html, rawTrackingNumber) {
+export function parsePaackTrackingHtml(html, rawPostcode) {
     // An empty body proves nothing about the shipment, so it stays indeterminate.
     if (!html.trim())
         throw new IndeterminateError('Paack', 'Paack returned an empty tracking response');
     if (NOT_FOUND_PAGE_PATTERN.test(html))
         throw new NotFoundError('Paack');
-    return parsePaackTrackingResponse(remixContext(html), rawTrackingNumber);
+    return parsePaackTrackingResponse(remixContext(html), rawPostcode);
 }
 export class PaackTracker {
     timeoutMs;
@@ -227,27 +259,39 @@ export class PaackTracker {
         const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
         const postcode = normalizePaackPostcode(rawPostcode);
         const budget = lookupBudget(context, this.timeoutMs);
-        const { response, bytes } = await fetchBounded(paackTrackingUrl(trackingNumber, postcode), {
-            signal: budget.signal,
-            headers: {
-                Accept: 'text/html,application/xhtml+xml',
-                'Accept-Language': 'fr-FR,fr;q=0.9,en;q=0.8',
-                'User-Agent': this.userAgent,
-            },
-        }, {
-            provider: 'Paack tracking',
-            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
-            maxBytes: MAX_RESPONSE_BYTES,
-            redirect: 'manual',
-            fetcher: this.fetcher,
-            allowHttpError: true,
-        });
-        if (response.status === 404 || (response.status >= 300 && response.status < 400)) {
-            throw new NotFoundError('Paack');
+        let url = paackTrackingUrl(trackingNumber, postcode);
+        for (let redirects = 0;; redirects += 1) {
+            const { response, bytes } = await fetchBounded(url, {
+                signal: budget.signal,
+                headers: {
+                    Accept: 'text/html,application/xhtml+xml',
+                    'Accept-Language': 'fr-FR,fr;q=0.9,en;q=0.8',
+                    'User-Agent': this.userAgent,
+                },
+            }, {
+                provider: 'Paack tracking',
+                timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
+                maxBytes: MAX_RESPONSE_BYTES,
+                redirect: 'manual',
+                fetcher: this.fetcher,
+                allowHttpError: true,
+            });
+            if (response.status >= 300 && response.status < 400) {
+                const target = redirectTarget(response.headers.get('location'), url, trackingNumber, postcode);
+                if (target && 'notFound' in target)
+                    throw new NotFoundError('Paack');
+                if (!target || redirects >= MAX_REDIRECTS) {
+                    throw new IndeterminateError('Paack', 'Paack redirected the lookup without an answer');
+                }
+                url = target.url;
+                continue;
+            }
+            if (response.status === 404)
+                throw new NotFoundError('Paack');
+            if (!response.ok)
+                throw new UpstreamHttpError('Paack tracking', response.status);
+            return parsePaackTrackingHtml(decodeText(bytes), postcode);
         }
-        if (!response.ok)
-            throw new UpstreamHttpError('Paack tracking', response.status);
-        return parsePaackTrackingHtml(decodeText(bytes), trackingNumber);
     }
 }
 export const adapter = (environment) => {

package/dist/carriers/paack/status.d.ts

@@ -12,6 +12,11 @@
  * delivery ones, so "notDelivered" can never match the "delivered" substring.
  * The provider's own wording is never returned; each mapped entry supplies the
  * English description we display.
+ *
+ * Aggregators relay the English text of Paack's timeline instead of its
+ * identifiers. `paackScan` maps those labels exactly, never by substring, and
+ * stores the same description as the direct lookup so both copies of a scan
+ * read alike.
  */
 import type { CarrierStatus } from '../../core/result/index.js';
 import type { Stage } from '../../generated/catalog.js';
@@ -23,4 +28,9 @@ export interface ClassifiedPaackStatus {
 }
 /** Reduce a provider identifier or label to lower-case letters and digits. */
 export declare function statusKey(value: unknown): string;
+/** The stage and stored wording of a Paack timeline label an aggregator relays. */
+export declare function paackScan(label: string): {
+    stage: Stage;
+    wording: string;
+} | undefined;
 export declare function classifyPaackEvent(value: JsonObject): ClassifiedPaackStatus;

package/dist/carriers/paack/status.js

@@ -7,6 +7,26 @@ export function statusKey(value) {
 function includesAny(value, candidates) {
     return candidates.some((candidate) => value.includes(candidate));
 }
+const REGISTERED = { status: 'pending', stage: 'registered', description: 'Shipment registered' };
+const ACCEPTED = { status: 'in_transit', stage: 'accepted', description: 'Shipment accepted' };
+const OUT_FOR_DELIVERY = {
+    status: 'out_for_delivery',
+    stage: 'out_for_delivery',
+    description: 'Out for delivery',
+};
+const DELIVERED = { status: 'delivered', stage: 'delivered', description: 'Delivered' };
+/** Paack's English timeline labels, keyed like `statusKey`, with the identifier each one renders. */
+const RELAYED = new Map([
+    ['orderdetailsreceived', REGISTERED], // manifested
+    ['inpaacksdistributioncentre', ACCEPTED], // scannedAtOrigin
+    ['outfordelivery', OUT_FOR_DELIVERY], // inDelivery
+    ['delivered', DELIVERED], // delivered
+]);
+/** The stage and stored wording of a Paack timeline label an aggregator relays. */
+export function paackScan(label) {
+    const entry = RELAYED.get(statusKey(label));
+    return entry && { stage: entry.stage, wording: entry.description };
+}
 export function classifyPaackEvent(value) {
     const key = `${statusKey(value.label)} ${statusKey(value.id)}`;
     if (includesAny(key, [
@@ -40,19 +60,13 @@ export function classifyPaackEvent(value) {
         'undelivered',
     ]))
         return { status: 'exception', stage: 'failed_attempt', description: 'Delivery issue' };
-    if (includesAny(key, ['delivered', 'deliverycompleted'])) {
-        return { status: 'delivered', stage: 'delivered', description: 'Delivered' };
-    }
+    if (includesAny(key, ['delivered', 'deliverycompleted']))
+        return { ...DELIVERED };
     if (includesAny(key, ['readyforpickup', 'atpickuppoint'])) {
         return { status: 'out_for_delivery', stage: 'ready_for_pickup', description: 'Ready for pickup' };
     }
-    if (includesAny(key, ['outfordelivery', 'driverassigned', 'inprogress'])) {
-        return {
-            status: 'out_for_delivery',
-            stage: 'out_for_delivery',
-            description: 'Out for delivery',
-        };
-    }
+    if (includesAny(key, ['outfordelivery', 'indelivery', 'driverassigned', 'inprogress']))
+        return { ...OUT_FOR_DELIVERY };
     if (includesAny(key, [
         'manifested',
         'created',
@@ -63,10 +77,9 @@ export function classifyPaackEvent(value) {
         'appointmentrescheduled',
         'appointmentscheduled',
     ]))
-        return { status: 'pending', stage: 'registered', description: 'Shipment registered' };
-    if (includesAny(key, ['scannedatorigin'])) {
-        return { status: 'in_transit', stage: 'accepted', description: 'Shipment accepted' };
-    }
+        return { ...REGISTERED };
+    if (includesAny(key, ['scannedatorigin']))
+        return { ...ACCEPTED };
     if (includesAny(key, [
         'received',
         'collected',

package/dist/carriers/paack/statuses.json

@@ -209,6 +209,14 @@
       "firstSeen": "2026-09-12",
       "note": "Identifier substring inherited from the pre-package adapter; source not recorded."
     },
+    {
+      "code": "indelivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-07",
+      "note": "Timeline step SP002, rendered as \"Out for delivery\"; listed without a timestamp before it happens."
+    },
     {
       "code": "driverassigned",
       "language": "en",
@@ -229,9 +237,9 @@
       "code": "manifested",
       "language": "en",
       "stage": "registered",
-      "confirmedBy": "prior-art",
+      "confirmedBy": "live",
       "firstSeen": "2026-09-12",
-      "note": "Identifier substring inherited from the pre-package adapter; source not recorded."
+      "note": "Timeline step SM001: the retailer sent the order details."
     },
     {
       "code": "created",
@@ -293,9 +301,9 @@
       "code": "scannedatorigin",
       "language": "en",
       "stage": "accepted",
-      "confirmedBy": "fixture",
+      "confirmedBy": "live",
       "firstSeen": "2026-09-12",
-      "note": "Exercised by the offline active-label table via scannedAtOriginHeader."
+      "note": "Timeline step SM002, Paack's first scan; also reached as scannedAtOriginHeader."
     },
     {
       "code": "received",
@@ -352,6 +360,38 @@
       "confirmedBy": "fixture",
       "firstSeen": "2026-09-12",
       "note": "Exercised by the offline active-label table via pudoAssignedHeader."
+    },
+    {
+      "wording": "Order details received",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-07",
+      "note": "Paack's page label for manifested, relayed by ParcelsApp; stored as \"Shipment registered\"."
+    },
+    {
+      "wording": "In Paack's distribution centre",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-07",
+      "note": "Paack's page label for scannedAtOrigin, relayed by ParcelsApp; stored as \"Shipment accepted\"."
+    },
+    {
+      "wording": "Out for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-07",
+      "note": "Paack's page label for inDelivery."
+    },
+    {
+      "wording": "Delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-07",
+      "note": "Paack's page label for delivered."
     }
   ]
 }

package/dist/carriers/spring-gds/carrier.json

@@ -77,7 +77,7 @@
   "detection": [
     {
       "id": "spring-gds-1",
-      "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
+      "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
       "confidence": "high",
       "checksum": "s10"
     },

package/dist/cli/index.js

@@ -9,7 +9,7 @@ const help = `Universal Parcel Scraper
 
   parcel-scraper detect <number, link or text>
   parcel-scraper recognize <number>
-  parcel-scraper track <number> [--carrier <id>] [--postcode <value>] [--tracking-url <url>] [--country-hint <code>]
+  parcel-scraper track <number> [--carrier <id>] [--postcode <value>] [--tracking-url <url>]
   parcel-scraper carriers
   parcel-scraper serve [--host <address>] [--port <port>]
 

package/dist/core/adapter/index.d.ts

@@ -8,7 +8,7 @@ export interface TrackingInput {
     trackingUrl?: string | null;
     /** The delivery postcode for carriers that need one; part of the tracking credential. */
     postcode?: string | null;
-    /** ISO country code or English name used only to retry an empty universal lookup; never shipment evidence. */
+    /** @deprecated Accepted for compatibility; no adapter or provider reads it. */
     countryHint?: string | null;
     /**
      * The zone of the carrier the parcel is filed under, for universal providers

package/dist/data/catalog.json

@@ -331,7 +331,7 @@
         ],
         "detectionRules": [
             {
-                "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
+                "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
                 "confidence": "high",
                 "checksum": "s10"
             },
@@ -1090,7 +1090,7 @@
                 "confidence": "low"
             },
             {
-                "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
+                "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
                 "confidence": "high",
                 "checksum": "s10"
             }
@@ -1131,7 +1131,7 @@
         ],
         "detectionRules": [
             {
-                "pattern": "^(?:PZ|XU|XW|XY)\\d{9}[A-Z]{2}$",
+                "pattern": "^(?:PZ|XR|XT|XU|XW|XY)\\d{9}[A-Z]{2}$",
                 "confidence": "high",
                 "checksum": "s10"
             },
@@ -1746,7 +1746,7 @@
         "linkRules": [],
         "detectionRules": [
             {
-                "pattern": "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|CL$)[A-Z]{2}$",
+                "pattern": "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|TS$|JF$|CL$)[A-Z]{2}$",
                 "confidence": "high",
                 "checksum": "s10"
             }

package/dist/facade/index.d.ts

@@ -24,7 +24,7 @@ export interface ParcelInput {
     number: string;
     carrier?: string;
     postcode?: string | null;
-    /** A destination or visitor country hint for an empty universal lookup; never shipment evidence. */
+    /** @deprecated Accepted for compatibility; it no longer affects a lookup. */
     countryHint?: string | null;
     trackingUrl?: string | null;
 }

package/dist/generated/catalog.d.ts

@@ -217,7 +217,7 @@ export declare const CARRIER_CATALOG: {
             readonly path: "/details/([^/?#]+)";
         }];
         readonly detectionRules: readonly [{
-            readonly pattern: "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}NL$";
+            readonly pattern: "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}NL$";
             readonly confidence: "high";
             readonly checksum: "s10";
         }, {
@@ -678,7 +678,7 @@ export declare const CARRIER_CATALOG: {
             readonly pattern: "^[A-Z0-9]{2}\\d{11}$";
             readonly confidence: "low";
         }, {
-            readonly pattern: "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}FR$";
+            readonly pattern: "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}FR$";
             readonly confidence: "high";
             readonly checksum: "s10";
         }];
@@ -703,7 +703,7 @@ export declare const CARRIER_CATALOG: {
             readonly params: readonly ["listeNumerosLT", "listeNumeros", "numeroLT"];
         }];
         readonly detectionRules: readonly [{
-            readonly pattern: "^(?:PZ|XU|XW|XY)\\d{9}[A-Z]{2}$";
+            readonly pattern: "^(?:PZ|XR|XT|XU|XW|XY)\\d{9}[A-Z]{2}$";
             readonly confidence: "high";
             readonly checksum: "s10";
         }, {
@@ -1123,7 +1123,7 @@ export declare const CARRIER_CATALOG: {
         readonly trackingSiteName: "17TRACK";
         readonly linkRules: readonly [];
         readonly detectionRules: readonly [{
-            readonly pattern: "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|CL$)[A-Z]{2}$";
+            readonly pattern: "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|TS$|JF$|CL$)[A-Z]{2}$";
             readonly confidence: "high";
             readonly checksum: "s10";
         }];

package/dist/generated/catalog.js

@@ -332,7 +332,7 @@ export const CARRIER_CATALOG = {
         ],
         "detectionRules": [
             {
-                "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
+                "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}NL$",
                 "confidence": "high",
                 "checksum": "s10"
             },
@@ -1091,7 +1091,7 @@ export const CARRIER_CATALOG = {
                 "confidence": "low"
             },
             {
-                "pattern": "^(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
+                "pattern": "^(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}FR$",
                 "confidence": "high",
                 "checksum": "s10"
             }
@@ -1132,7 +1132,7 @@ export const CARRIER_CATALOG = {
         ],
         "detectionRules": [
             {
-                "pattern": "^(?:PZ|XU|XW|XY)\\d{9}[A-Z]{2}$",
+                "pattern": "^(?:PZ|XR|XT|XU|XW|XY)\\d{9}[A-Z]{2}$",
                 "confidence": "high",
                 "checksum": "s10"
             },
@@ -1747,7 +1747,7 @@ export const CARRIER_CATALOG = {
         "linkRules": [],
         "detectionRules": [
             {
-                "pattern": "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|CL$)[A-Z]{2}$",
+                "pattern": "^(?![CL][A-Z]\\d{9}DE$)(?!AS\\d{9}US$)(?!(?:PZ|XR|XT|XU|XW|XY))[A-Z]{2}\\d{9}(?!CA$|CH$|FR$|IN$|NL$|GB$|IE$|BE$|PT$|NZ$|SG$|JP$|KR$|TH$|HK$|MY$|CN$|NO$|BR$|ES$|SE$|DK$|AT$|YP$|TS$|JF$|CL$)[A-Z]{2}$",
                 "confidence": "high",
                 "checksum": "s10"
             }

package/dist/providers/parcelsapp/adapter.d.ts

@@ -19,6 +19,6 @@ export declare class ParcelsAppTracker {
     readonly options: ParcelsAppOptions;
     private readonly http;
     constructor(options?: ParcelsAppOptions);
-    fetch(trackingNumber: string, budgetMs?: number, postcode?: string | null, timezone?: string | null, signal?: AbortSignal, countryHint?: string | null): Promise<CarrierResult>;
+    fetch(trackingNumber: string, budgetMs?: number, postcode?: string | null, timezone?: string | null, signal?: AbortSignal): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;

package/dist/providers/parcelsapp/adapter.js

@@ -21,7 +21,7 @@ import { facilityZone, LatestScan, relaysFacilityClock } from '../shared/facilit
 import { universalCarrierHints } from '../shared/hints.js';
 import { event, isNotice, localEvent, numberOf, result } from '../shared/result.js';
 import { carrierScan, markReturnLeg } from '../shared/scans.js';
-import { PARCELSAPP_API, parcelsAppCountry, ParcelsAppHttpClient } from './http.js';
+import { PARCELSAPP_API, ParcelsAppHttpClient } from './http.js';
 const SOURCE = 'ParcelsApp';
 const MAX_EVENTS = 1000;
 export const PARCELSAPP_BUDGET_MS = 45_000;
@@ -351,14 +351,13 @@ export class ParcelsAppTracker {
         this.options = options;
         this.http = options.httpClient === undefined ? new ParcelsAppHttpClient(options.fetcher, options.userAgent) : options.httpClient;
     }
-    async fetch(trackingNumber, budgetMs = this.options.timeoutMs ?? PARCELSAPP_BUDGET_MS, postcode, timezone = null, signal, countryHint) {
+    async fetch(trackingNumber, budgetMs = this.options.timeoutMs ?? PARCELSAPP_BUDGET_MS, postcode, timezone = null, signal) {
         const number = numberOf(trackingNumber);
         if (!Number.isFinite(budgetMs) || budgetMs < 1)
             throw new TypeError('ParcelsApp timeout must be positive');
         const deadline = performance.now() + budgetMs;
-        const country = parcelsAppCountry(countryHint);
-        const request = async (remainingMs, signal, manualCountry) => {
-            const payload = await this.http.fetch(number, Math.max(1, Math.min(DIRECT_BUDGET_MS, Math.floor(remainingMs))), postcode, signal, manualCountry);
+        const request = async (remainingMs, signal) => {
+            const payload = await this.http.fetch(number, Math.max(1, Math.min(DIRECT_BUDGET_MS, Math.floor(remainingMs))), postcode, signal);
             // This endpoint returns one shipment per POST, synchronously, with no
             // shared session or polling handle. Each retry keeps its own request
             // binding. Numberless browser captures never get this exemption.
@@ -375,17 +374,13 @@ export class ParcelsAppTracker {
                 id: 'retry',
                 enabled: this.http !== null,
                 // Uncached carrier aggregation can outlive a timed-out HTTP request.
-                // Retry a replayable network failure with the same input. An empty
-                // answer can instead try the caller's country once, as the website's
-                // selector does. Both share this step and the original lookup budget.
-                recovers: (error) => (error instanceof UpstreamNetworkError && deadline - performance.now() > RETRY_DELAY_MS + 1)
-                    || (country !== null && error instanceof NoHistoryError && deadline - performance.now() > 1),
-                run: async ({ signal, previousError }) => {
-                    const empty = previousError instanceof NoHistoryError;
-                    if (!empty)
-                        await timers.setTimeout(RETRY_DELAY_MS, undefined, { signal });
+                // Retry a replayable network failure with the same input, within the
+                // original lookup budget.
+                recovers: (error) => error instanceof UpstreamNetworkError && deadline - performance.now() > RETRY_DELAY_MS + 1,
+                run: async ({ signal }) => {
+                    await timers.setTimeout(RETRY_DELAY_MS, undefined, { signal });
                     signal.throwIfAborted();
-                    return request(deadline - performance.now(), signal, empty ? country : null);
+                    return request(deadline - performance.now(), signal);
                 },
             }, {
                 id: 'trawl',
@@ -418,6 +413,6 @@ export const adapter = (environment) => {
     return {
         id: SOURCE,
         steps: ['direct', 'retry', 'trawl'],
-        track: (input, context) => tracker.fetch(input.number, context?.budgetMs, input.postcode, input.timezone ?? null, context?.signal, input.countryHint),
+        track: (input, context) => tracker.fetch(input.number, context?.budgetMs, input.postcode, input.timezone ?? null, context?.signal),
     };
 };

package/dist/providers/parcelsapp/http.d.ts

@@ -1,12 +1,10 @@
-/** The country selector uses English names, not ISO codes. */
-export declare function parcelsAppCountry(value: unknown): string | null;
 export declare const PARCELSAPP_API = "https://parcelsapp.com/api/v2/parcels";
 /** MurmurHash2 with the public website's seed, over ASCII protocol data. */
 export declare function parcelsAppChecksum(text: string): number;
-export declare function parcelsAppRequest(trackingNumber: string, postcode?: string | null, countryHint?: string | null): URLSearchParams;
+export declare function parcelsAppRequest(trackingNumber: string, postcode?: string | null): URLSearchParams;
 export declare class ParcelsAppHttpClient {
     #private;
     readonly fetcher?: typeof fetch | undefined;
     constructor(fetcher?: typeof fetch | undefined, userAgent?: string);
-    fetch(trackingNumber: string, timeoutMs: number, postcode?: string | null, signal?: AbortSignal, countryHint?: string | null): Promise<unknown>;
+    fetch(trackingNumber: string, timeoutMs: number, postcode?: string | null, signal?: AbortSignal): Promise<unknown>;
 }