universal-parcel-scraper 0.40.0-main.395 → 0.41.0-main.397

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 **103 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **104 dedicated adapters** and **5 universal fallbacks**
 
 <sub>124 catalog entries · 58 countries represented</sub>
 <!-- /GENERATED:summary -->
@@ -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 2,204 such statuses, each filed under one stage.
+The carrier folders record 2,211 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

@@ -949,15 +949,14 @@
       "requirements": [
         {
           "field": "postcode",
-          "whenTrackingNumber": "^(?![0-9]{26}$).*$",
-          "validator": "francePostcode",
+          "whenTrackingNumber": "^[0-9]{8}$",
+          "validator": "internationalPostcode",
           "label": "Delivery postcode",
           "type": "text",
-          "placeholder": "75001",
-          "help": "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.",
-          "pattern": "^[0-9]{5}$",
-          "maxLength": 5,
-          "inputMode": "numeric",
+          "help": "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.",
+          "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+          "maxLength": 12,
+          "inputMode": "text",
           "autoComplete": "postal-code"
         }
       ]
@@ -1109,8 +1108,9 @@
     "timezone": "Europe/Paris",
     "tracking": {
       "mode": "automatic",
-      "adapter": "la-poste",
-      "recognitionRank": 45
+      "adapter": "chronopost",
+      "recognitionRank": 45,
+      "localClocks": true
     },
     "canaryUrl": "https://www.chronopost.fr/tracking-no-cms/suivi-page",
     "trackingUrlTemplate": "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}",
@@ -1644,14 +1644,13 @@
       "requirements": [
         {
           "field": "postcode",
-          "validator": "swissOrFrancePostcode",
+          "validator": "internationalPostcode",
           "label": "Delivery postcode",
           "type": "text",
-          "placeholder": "10115",
-          "help": "GLS requires the four- or five-digit delivery postcode to show the detailed event history.",
-          "pattern": "^[0-9]{4,5}$",
-          "maxLength": 5,
-          "inputMode": "numeric",
+          "help": "GLS requires the delivery postcode to show the detailed event history.",
+          "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+          "maxLength": 12,
+          "inputMode": "text",
           "autoComplete": "postal-code"
         }
       ],

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 124,
-  "activeAdapters": 103,
+  "activeAdapters": 104,
   "countries": 58,
   "referenceCarriers": 113,
   "comparison": {

package/dist/browser/scraper.js

@@ -852,15 +852,14 @@ var ve = {
 			adapter: "mondial-relay",
 			requirements: [{
 				field: "postcode",
-				whenTrackingNumber: "^(?![0-9]{26}$).*$",
-				validator: "francePostcode",
+				whenTrackingNumber: "^[0-9]{8}$",
+				validator: "internationalPostcode",
 				label: "Delivery postcode",
 				type: "text",
-				placeholder: "75001",
-				help: "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.",
-				pattern: "^[0-9]{5}$",
-				maxLength: 5,
-				inputMode: "numeric",
+				help: "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.",
+				pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+				maxLength: 12,
+				inputMode: "text",
 				autoComplete: "postal-code"
 			}]
 		},
@@ -984,8 +983,9 @@ var ve = {
 		timezone: "Europe/Paris",
 		tracking: {
 			mode: "automatic",
-			adapter: "la-poste",
-			recognitionRank: 45
+			adapter: "chronopost",
+			recognitionRank: 45,
+			localClocks: !0
 		},
 		canaryUrl: "https://www.chronopost.fr/tracking-no-cms/suivi-page",
 		trackingUrlTemplate: "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}",
@@ -1390,14 +1390,13 @@ var ve = {
 			adapter: "gls-de",
 			requirements: [{
 				field: "postcode",
-				validator: "swissOrFrancePostcode",
+				validator: "internationalPostcode",
 				label: "Delivery postcode",
 				type: "text",
-				placeholder: "10115",
-				help: "GLS requires the four- or five-digit delivery postcode to show the detailed event history.",
-				pattern: "^[0-9]{4,5}$",
-				maxLength: 5,
-				inputMode: "numeric",
+				help: "GLS requires the delivery postcode to show the detailed event history.",
+				pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+				maxLength: 12,
+				inputMode: "text",
 				autoComplete: "postal-code"
 			}],
 			recognitionRank: 50,
@@ -8939,17 +8938,23 @@ function Ks(e, t) {
 	return r.protocol = "https:", r.hostname = Bs, r.port = "", r.toString();
 }
 //#endregion
+//#region core/catalog/postcode.ts
+var qs = /^(?=.{3,12}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/;
+function Js(e) {
+	return e.trim().toUpperCase().replace(/\s+/g, " ");
+}
+//#endregion
 //#region core/catalog/inputs.ts
-function qs(e, t, n, r) {
+function Ys(e, t, n, r) {
 	let i = {
 		trackingUrl: n.trim() || null,
 		postcode: r.trim() || null
 	}, a = e === "mondial-relay" && /^\d{26}$/.test(t);
 	if (a && !he(t)) throw TypeError("Invalid Mondial Relay barcode");
 	let o = new Map(je(e, t).map((e) => [e.field, e]));
-	a && i.postcode && o.set("postcode", {
+	(a || e === "mondial-relay" && /^(?:\d{10}|\d{12})$/.test(t)) && i.postcode && o.set("postcode", {
 		field: "postcode",
-		validator: "francePostcode"
+		validator: "internationalPostcode"
 	});
 	for (let [e, t] of Object.entries(i)) if (t !== null && !o.has(e)) throw TypeError(e === "trackingUrl" ? "A tracking URL is not used for this carrier or tracking number" : "A delivery postcode is not used for this carrier");
 	for (let [n, r] of o) {
@@ -8976,8 +8981,8 @@ function qs(e, t, n, r) {
 				if (!/^\d{4,5}$/.test(a)) throw TypeError(`${y(e).displayName} requires a four- or five-digit delivery postcode`);
 				break;
 			case "internationalPostcode":
-				if (!Js.test(Ys(a))) throw TypeError(`${y(e).displayName} requires a valid delivery postcode`);
-				i[n] = Ys(a);
+				if (!qs.test(Js(a))) throw TypeError(`${y(e).displayName} requires a valid delivery postcode`);
+				i[n] = Js(a);
 				break;
 			case "paackPostcode": {
 				let e = a.toLocaleUpperCase("en-US");
@@ -8990,13 +8995,9 @@ function qs(e, t, n, r) {
 	}
 	return i;
 }
-var Js = /^(?=.{3,12}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/;
-function Ys(e) {
-	return e.trim().toUpperCase().replace(/\s+/g, " ");
-}
 function Xs(e) {
-	let t = Ys(e);
-	if (!Js.test(t)) throw TypeError("A valid delivery postcode is required");
+	let t = Js(e);
+	if (!qs.test(t)) throw TypeError("A valid delivery postcode is required");
 	return t;
 }
 var Zs = { carriers: [
@@ -10778,4 +10779,4 @@ function pc(e = !1, t) {
 	}).sources;
 }
 //#endregion
-export { Se as AMAZON_NUMBER_PATTERN, Ne as AUTOMATIC_CARRIER_IDS, oc as BROWSER_SOURCES, f as BudgetExceededError, Ve as CARRIERS, ve as CARRIER_CATALOG, v as CARRIER_DEFINITIONS, ye as CARRIER_IDS, Pe as CARRIER_NAMES, t as CarrierError, a as ChallengeError, No as EXPLICIT_OFFSET_PATTERN, r as IndeterminateError, l as InputRequiredError, u as InvalidInputError, ys as MAX_RECOGNITIONS, s as MaintenanceError, i as NoHistoryError, n as NotFoundError, o as RateLimitedError, Ue as SELECTABLE_CARRIERS, xe as STAGES, c as SchemaError, St as TRACKING_CANDIDATE_PATTERNS, Fe as TRACKING_LINK_RULES, d as TransportError, ac as UNIVERSAL_SOURCES, m as UpstreamHttpError, ee as UpstreamNetworkError, je as activeRequirements, Te as amazonMarketplace, Ee as amazonOrdersUrl, De as amazonShippingOrigin, Oe as amazonShippingUrl, os as calendarDay, es as canadaProvinceTimeZone, Ae as carrierAdapter, y as carrierDefinition, h as carrierErrorKind, He as carrierInfo, Ie as carrierLinkRules, We as carrierRequirements, ke as carrierTimezone, _t as checksumRejections, us as classifyStage, Ut as classifyWording, Jo as countryCode, Yo as countryTimeZone, Is as deliveryHandoff, vt as detectCarrier, x as detectCarrierMatch, is as epochMillisTime, as as epochSecondsTime, ne as errorTypeOf, Rt as eventPoint, Fo as explicitOffsetTime, hs as failureHint, ms as failureKind, _e as formatTrackingNumber, Fs as hasDirectHandoffAdapter, ds as inferStage, Ce as isAmazonTrackingNumber, ge as isPlanzerSharedTrackingNumber, Xe as isValidCorreosSpainCheckLetter, ae as isValidDhlExpressWaybill, $e as isValidDpdParcelNumber, at as isValidGlsParcelNumber, ot as isValidHermesParcelNumber, he as isValidMondialRelayBarcode, pe as isValidPocztaPolskaBarcode, b as isValidS10TrackingNumber, me as isValidSscc, se as isValidTntConsignmentNumber, dt as isValidUspsPackageBarcode, Lo as isoTime, Et as keywordNumberInText, Ht as languageStageStatus, qe as localizedCarrierUrl, Le as matchesDomain, zo as mislabeledLocalTime, Bo as mislabeledWallTime, qs as normalizeCarrierInputs, zt as normalizeCarrierResult, Xs as normalizeDeliveryPostcode, _ as normalizeTrackingNumber, dc as orderUniversalSources, Mt as parseTrackingInput, cc as priorityUniversalSource, xs as recognitionCandidates, bs as recognitionNumberShape, Cs as recognizeAll, Ct as recognizedNumberInText, rs as regionHasTown, Me as requiredRequirements, Ge as requirementSatisfied, we as requiresAmazonAccount, ps as resolveResult, ls as resultHasUpdate, cs as resultStage, g as retryAfterMsOf, Uo as settleGuessedClocks, Ts as settleRecognition, Vo as sharedClockZone, fs as stageSource, st as supportsSwissPostHandoff, Xo as timeZoneCountry, ts as townKey, Vt as trackingLanguageStage, ze as trackingLink, Re as trackingNumberForLink, Ke as tracksAutomatically, fc as universalPlan, sc as universalSourceBudget, pc as universalSources, Qo as usStateTimeZone, bt as validTrackingNumber, Ks as validateDachserTrackingUrl, Gs as validatePlanzerSharedUrl, Wt as wordingStage, Io as zonedTime };
+export { Se as AMAZON_NUMBER_PATTERN, Ne as AUTOMATIC_CARRIER_IDS, oc as BROWSER_SOURCES, f as BudgetExceededError, Ve as CARRIERS, ve as CARRIER_CATALOG, v as CARRIER_DEFINITIONS, ye as CARRIER_IDS, Pe as CARRIER_NAMES, t as CarrierError, a as ChallengeError, No as EXPLICIT_OFFSET_PATTERN, r as IndeterminateError, l as InputRequiredError, u as InvalidInputError, ys as MAX_RECOGNITIONS, s as MaintenanceError, i as NoHistoryError, n as NotFoundError, o as RateLimitedError, Ue as SELECTABLE_CARRIERS, xe as STAGES, c as SchemaError, St as TRACKING_CANDIDATE_PATTERNS, Fe as TRACKING_LINK_RULES, d as TransportError, ac as UNIVERSAL_SOURCES, m as UpstreamHttpError, ee as UpstreamNetworkError, je as activeRequirements, Te as amazonMarketplace, Ee as amazonOrdersUrl, De as amazonShippingOrigin, Oe as amazonShippingUrl, os as calendarDay, es as canadaProvinceTimeZone, Ae as carrierAdapter, y as carrierDefinition, h as carrierErrorKind, He as carrierInfo, Ie as carrierLinkRules, We as carrierRequirements, ke as carrierTimezone, _t as checksumRejections, us as classifyStage, Ut as classifyWording, Jo as countryCode, Yo as countryTimeZone, Is as deliveryHandoff, vt as detectCarrier, x as detectCarrierMatch, is as epochMillisTime, as as epochSecondsTime, ne as errorTypeOf, Rt as eventPoint, Fo as explicitOffsetTime, hs as failureHint, ms as failureKind, _e as formatTrackingNumber, Fs as hasDirectHandoffAdapter, ds as inferStage, Ce as isAmazonTrackingNumber, ge as isPlanzerSharedTrackingNumber, Xe as isValidCorreosSpainCheckLetter, ae as isValidDhlExpressWaybill, $e as isValidDpdParcelNumber, at as isValidGlsParcelNumber, ot as isValidHermesParcelNumber, he as isValidMondialRelayBarcode, pe as isValidPocztaPolskaBarcode, b as isValidS10TrackingNumber, me as isValidSscc, se as isValidTntConsignmentNumber, dt as isValidUspsPackageBarcode, Lo as isoTime, Et as keywordNumberInText, Ht as languageStageStatus, qe as localizedCarrierUrl, Le as matchesDomain, zo as mislabeledLocalTime, Bo as mislabeledWallTime, Ys as normalizeCarrierInputs, zt as normalizeCarrierResult, Xs as normalizeDeliveryPostcode, _ as normalizeTrackingNumber, dc as orderUniversalSources, Mt as parseTrackingInput, cc as priorityUniversalSource, xs as recognitionCandidates, bs as recognitionNumberShape, Cs as recognizeAll, Ct as recognizedNumberInText, rs as regionHasTown, Me as requiredRequirements, Ge as requirementSatisfied, we as requiresAmazonAccount, ps as resolveResult, ls as resultHasUpdate, cs as resultStage, g as retryAfterMsOf, Uo as settleGuessedClocks, Ts as settleRecognition, Vo as sharedClockZone, fs as stageSource, st as supportsSwissPostHandoff, Xo as timeZoneCountry, ts as townKey, Vt as trackingLanguageStage, ze as trackingLink, Re as trackingNumberForLink, Ke as tracksAutomatically, fc as universalPlan, sc as universalSourceBudget, pc as universalSources, Qo as usStateTimeZone, bt as validTrackingNumber, Ks as validateDachserTrackingUrl, Gs as validatePlanzerSharedUrl, Wt as wordingStage, Io as zonedTime };

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

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

package/dist/carriers/chronopost/adapter.js

@@ -0,0 +1,40 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { IndeterminateError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
+import { CHRONOPOST_MAX_BYTES, CHRONOPOST_NAMESPACE, normalizeChronopostNumber, parseChronopostTrackingXml } from './parser.js';
+// The official WSDL declares this read-only operation without account credentials.
+const ENDPOINT = 'https://ws.chronopost.fr/tracking-cxf/TrackingServiceWS';
+export class ChronopostTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizeChronopostNumber(raw);
+        return runSteps({ carrier: 'chronopost', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            recorder: this.options.recorder }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    const { response, bytes } = await fetchBounded(ENDPOINT, {
+                        method: 'POST', signal,
+                        headers: { Accept: 'text/xml', 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '""',
+                            'User-Agent': userAgentOf(this.options.userAgent) },
+                        body: `<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:trk="${CHRONOPOST_NAMESPACE}">`
+                            + `<soap:Body><trk:trackSkybillV2><language>fr_FR</language><skybillNumber>${number}</skybillNumber>`
+                            + '</trk:trackSkybillV2></soap:Body></soap:Envelope>',
+                    }, { provider: 'Chronopost tracking', timeoutMs: Math.max(1, Math.floor(remainingMs)),
+                        maxBytes: CHRONOPOST_MAX_BYTES, allowHttpStatuses: [404, 410], fetcher: this.options.fetcher });
+                    // An HTTP route failure is not the service's positive unknown-parcel reply.
+                    if ([404, 410].includes(response.status))
+                        throw new IndeterminateError('Chronopost', 'Chronopost tracking endpoint is unavailable');
+                    return parseChronopostTrackingXml(decodeText(bytes), number);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new ChronopostTracker(environment);
+    return {
+        id: 'chronopost', recordsSteps: true, steps: ['direct'],
+        track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeChronopostNumber(number))),
+    };
+};

package/dist/carriers/chronopost/carrier.json

@@ -16,20 +16,20 @@
   "timezone": "Europe/Paris",
   "tracking": {
     "mode": "automatic",
-    "adapter": "la-poste",
+    "adapter": "chronopost",
     "steps": [
-      "direct",
-      "retry"
+      "direct"
     ],
     "recognition": {
       "rank": 45
-    }
+    },
+    "localClocks": true
   },
   "capabilities": [
     "history",
     "location",
-    "eta",
-    "provider_code"
+    "provider_code",
+    "delivery_tracking_number"
   ],
   "portal": {
     "url": "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}",
@@ -43,10 +43,11 @@
     "scraped": [
       "status",
       "history",
-      "location",
+      "location"
+    ],
+    "discarded": [
       "eta"
     ],
-    "discarded": [],
     "unavailable": []
   },
   "links": [

package/dist/carriers/chronopost/parser.d.ts

@@ -0,0 +1,5 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const CHRONOPOST_MAX_BYTES = 2000000;
+export declare const CHRONOPOST_NAMESPACE = "http://cxf.tracking.soap.chronopost.fr/";
+export declare function normalizeChronopostNumber(raw: string): string;
+export declare function parseChronopostTrackingXml(xml: string, rawNumber: string): CarrierResult;

package/dist/carriers/chronopost/parser.js

@@ -0,0 +1,163 @@
+import { DateTime } from 'luxon';
+import { isValidDpdParcelNumber } from '../../core/detection/dpd.js';
+import { ChallengeError, IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { languageStageStatus } from '../../core/status/index.js';
+import { countryCode, explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { xmlDocument } from '../../core/transport/xml.js';
+import { chronopostStage, isChronopostNotification } from './status.js';
+export const CHRONOPOST_MAX_BYTES = 2_000_000;
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+export const CHRONOPOST_NAMESPACE = 'http://cxf.tracking.soap.chronopost.fr/';
+const MAX_EVENTS = 500;
+export function normalizeChronopostNumber(raw) {
+    const value = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^[A-Z]{2}\d{9}[A-Z]{2}$/.test(value) && !isValidDpdParcelNumber(value)) {
+        throw new InvalidInputError('Chronopost', 'Chronopost requires a postal-shaped identifier or a checked 15-character parcel number');
+    }
+    return value;
+}
+function children(node, name, uri = '') {
+    return node.children.filter(child => child.name === name && child.uri === uri);
+}
+function one(node, name, uri = '') {
+    const found = children(node, name, uri);
+    if (found.length !== 1)
+        throw new SchemaError('Chronopost', 'Chronopost returned an invalid tracking structure');
+    return found[0];
+}
+function scalar(node, name, required = false) {
+    const found = children(node, name);
+    if (found.length > 1 || found[0]?.children.length || (required && found.length !== 1)) {
+        throw new SchemaError('Chronopost', 'Chronopost returned an invalid tracking field');
+    }
+    return found[0]?.text.trim() ?? '';
+}
+function clock(raw) {
+    // Reject impossible offsets that Luxon otherwise normalizes.
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(raw)) {
+        const parsed = explicitOffsetTime(raw);
+        if (parsed)
+            return { time: parsed.iso };
+    }
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw) && DateTime.fromISO(raw, { zone: 'UTC' }).isValid) {
+        return { local_time: raw };
+    }
+    return raw ? { provider_time_text: clean(raw, 64) } : {};
+}
+/** Keep operational places, never the delivery-point address or shop contact block. */
+function location(office, place) {
+    if (/^[\p{L}\p{M} .,'’()-]{1,100} - [A-Z]{2}(?: \(depot \d{1,6}\))?$/u.test(place))
+        return place;
+    const shop = /^([\p{L}\p{M} .,'’-]{1,100}) - ([A-Z]{2}) - /u.exec(office);
+    if (shop)
+        return `${shop[1]}, ${shop[2]}`;
+    return /^[\p{L}\p{M} .,'’()/-]{1,160}$/u.test(office) ? office : '';
+}
+export function parseChronopostTrackingXml(xml, rawNumber) {
+    const requested = normalizeChronopostNumber(rawNumber);
+    const root = xmlDocument(xml, CHRONOPOST_MAX_BYTES);
+    if (!root || root.name !== 'Envelope' || root.uri !== SOAP) {
+        if (/<title>\s*Just a moment|cf-chl-|challenge-platform/i.test(xml))
+            throw new ChallengeError('Chronopost');
+        throw new SchemaError('Chronopost', 'Chronopost returned invalid tracking XML');
+    }
+    const body = one(root, 'Body', SOAP);
+    if (children(body, 'Fault', SOAP).length)
+        throw new IndeterminateError('Chronopost', 'Chronopost tracking returned a SOAP fault');
+    if (body.children.length !== 1)
+        throw new SchemaError('Chronopost', 'Chronopost returned ambiguous tracking results');
+    const response = one(body, 'trackSkybillV2Response', CHRONOPOST_NAMESPACE);
+    const result = one(response, 'return');
+    const errorCode = scalar(result, 'errorCode', true);
+    if (!/^\d+$/.test(errorCode))
+        throw new SchemaError('Chronopost', 'Chronopost returned an invalid tracking error code');
+    if (Number(errorCode) !== 0)
+        throw new IndeterminateError('Chronopost', 'Chronopost tracking is unavailable');
+    const history = one(result, 'listEventInfoComp');
+    // Compare the entire identity, without truncation or accepting a linked parcel as an alias.
+    const identity = scalar(history, 'skybillNumber', true).toUpperCase().replace(/[\s.-]/g, '');
+    if (identity !== requested) {
+        throw new SchemaError('Chronopost', 'Chronopost returned a different shipment');
+    }
+    const scans = children(history, 'events');
+    if (!scans.length)
+        throw new NotFoundError('Chronopost');
+    if (scans.length > MAX_EVENTS)
+        throw new SchemaError('Chronopost', 'Chronopost returned excessive tracking history');
+    const references = new Set();
+    const geoReferences = new Set();
+    const destinations = new Set();
+    const projected = scans.map((scan, index) => {
+        const description = clean(scalar(scan, 'eventLabel', true), 500);
+        const code = clean(scalar(scan, 'code'), 40);
+        if (!description)
+            throw new SchemaError('Chronopost', 'Chronopost returned an empty tracking event');
+        const extras = children(scan, 'infoCompList');
+        let place = '';
+        for (const extra of extras) {
+            const name = scalar(extra, 'name');
+            const value = scalar(extra, 'value');
+            if (name === 'Lieu')
+                place = value;
+            if (name === 'Numéro partenaire') {
+                const match = /^(?:GEO\/)?([A-Z0-9]{4,40})$/.exec(value.toUpperCase());
+                if (match) {
+                    references.add(match[1]);
+                    if (value.toUpperCase().startsWith('GEO/') && isValidDpdParcelNumber(match[1]))
+                        geoReferences.add(match[1]);
+                }
+            }
+            if (name === 'Point de livraison') {
+                // Only the terminal country is projected; discard the address itself.
+                const country = countryCode(/ - ([A-Z]{2})$/.exec(value)?.[1]);
+                if (country)
+                    destinations.add(country);
+            }
+        }
+        const event = {
+            ...clock(scalar(scan, 'eventDate')),
+            description,
+            location: location(scalar(scan, 'officeLabel'), place),
+            ...(code ? { provider_code: code } : {}),
+        };
+        const mapped = chronopostStage(code, description);
+        return { event, mapped, notification: isChronopostNotification(description), index };
+    });
+    // The operation returns oldest first. Reorder only when all scan clocks
+    // establish instants, so mixed local clocks cannot create a guessed order.
+    if (projected.every(scan => explicitOffsetTime(scan.event.time))) {
+        projected.sort((left, right) => explicitOffsetTime(left.event.time).timestamp
+            - explicitOffsetTime(right.event.time).timestamp || left.index - right.index);
+    }
+    let stage = 'pending';
+    let stageSource = 'none';
+    for (const scan of projected) {
+        if (!scan.notification && scan.mapped.source !== 'none') {
+            stage = scan.mapped.stage;
+            stageSource = scan.mapped.source;
+        }
+        // An alert records activity, but does not regress delivery or prove movement.
+        scan.event.stage = scan.notification ? stage : scan.mapped.stage;
+        scan.event.stage_source = scan.notification ? 'none' : scan.mapped.source;
+    }
+    const events = projected.reverse().slice(0, 100).map(scan => scan.event);
+    const latest = events[0];
+    const reference = references.size === 1 ? [...references][0] : undefined;
+    const destination = destinations.size === 1 ? [...destinations][0] : undefined;
+    // The typed Geopost reference and Germany destination propose a national
+    // lookup. The downstream adapter must still confirm ownership and activity.
+    const partner = reference && geoReferences.has(reference) && destination === 'DE' ? 'dpd-de' : undefined;
+    return {
+        status: languageStageStatus(stage),
+        current_stage: stage,
+        current_stage_source: stageSource,
+        last_status_text: latest.description,
+        last_update: latest.time ?? null,
+        expected_delivery: null,
+        ...(reference ? { delivery_tracking_number: reference } : {}),
+        ...(partner ? { delivery_carrier: partner } : {}),
+        ...(destination ? { destination_country: destination } : {}),
+        events,
+    };
+}

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

@@ -0,0 +1,4 @@
+import { type ClassifiedWording } from '../../core/status/index.js';
+export declare function isChronopostNotification(label: string): boolean;
+/** Partner events can reuse codes; the observed wording must agree with the code. */
+export declare function chronopostStage(code: string, label: string): ClassifiedWording;

package/dist/carriers/chronopost/status.js

@@ -0,0 +1,19 @@
+import { classifyWording } from '../../core/status/index.js';
+const observed = new Map([
+    ['DC', { label: "Colis en cours de préparation chez l'expéditeur", stage: 'registered' }],
+    ['DB', { label: "Colis déposé par l'expéditeur", stage: 'accepted' }],
+    ['SC', { label: "Tri effectué dans l'agence de départ", stage: 'in_transit' }],
+    ['TS', { label: "Colis en cours d'acheminement", stage: 'in_transit' }],
+    ['O', { label: "Colis en cours d'acheminement", stage: 'in_transit' }],
+    ['TP', { label: "Colis en cours d'acheminement", stage: 'in_transit' }],
+]);
+export function isChronopostNotification(label) {
+    return label === 'Destinataire informé par SMS ou mail';
+}
+/** Partner events can reuse codes; the observed wording must agree with the code. */
+export function chronopostStage(code, label) {
+    const known = observed.get(code);
+    if (known?.label === label)
+        return { stage: known.stage, source: 'carrier_map' };
+    return classifyWording(label, 'pending');
+}

package/dist/carriers/chronopost/statuses.json

@@ -42,6 +42,62 @@
       "confirmedBy": "fixture",
       "firstSeen": "2026-09-12",
       "note": "Observed on a Chronopost shipment with an empty group and the label 'Livraison effectuée'."
+    },
+    {
+      "code": "DC",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Colis en cours de préparation chez l'expéditeur",
+      "language": "fr"
+    },
+    {
+      "code": "DB",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Colis déposé par l'expéditeur",
+      "language": "fr"
+    },
+    {
+      "code": "SC",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Tri effectué dans l'agence de départ",
+      "language": "fr"
+    },
+    {
+      "code": "TS",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Colis en cours d'acheminement",
+      "language": "fr"
+    },
+    {
+      "code": "O",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Colis en cours d'acheminement",
+      "language": "fr"
+    },
+    {
+      "code": "TP",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "note": "Chronopost trackSkybillV2; code mapping requires matching wording.",
+      "wording": "Colis en cours d'acheminement",
+      "language": "fr"
+    },
+    {
+      "code": "SM",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "note": "Notification after an in-transit scan; inherits the preceding shipment stage rather than establishing a milestone.",
+      "wording": "Destinataire informé par SMS ou mail",
+      "language": "fr"
     }
   ]
 }

package/dist/carriers/dpd/adapter.js

@@ -2,6 +2,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { randomBytes } from 'node:crypto';
 import { load } from 'cheerio';
 import { lookupBudget } from '../../core/adapter/index.js';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
 import { dpdParcelNumber } from '../../core/detection/dpd.js';
 import { BudgetExceededError, carrierErrorKind, ChallengeError, IndeterminateError, InvalidInputError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
@@ -47,8 +48,6 @@ const TOKEN_FAILURE_MEMORY_MS = 30_000;
 /** The browser service may spend the whole request timeout plus its own transport allowance. */
 const SOLVER_ALLOWANCE_MS = 15_000;
 const MAX_BYTES = 10_000_000;
-/** Any country's postcode, as the catalog's `internationalPostcode` input takes it. */
-const DELIVERY_POSTCODE = /^(?=.{3,12}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/;
 /** Cloudflare interrupted the consignee page with an interactive challenge. */
 export class DPDChallengeError extends ChallengeError {
     constructor(message = 'DPD returned a Cloudflare browser challenge', options) {
@@ -537,7 +536,7 @@ export class DPDTracker {
         // DPD checks the postcode against the recipient's, and the service this
         // adapter asks also answers for parcels delivered in other countries: any
         // country's postcode goes through. The German unit reads German deliveries.
-        const resolvedPostcode = postcode.trim().toUpperCase().replace(/\s+/g, ' ');
+        const resolvedPostcode = deliveryPostcodeText(postcode);
         if (resolvedPostcode && !(this.country === 'DE' ? /^\d{5}$/ : DELIVERY_POSTCODE).test(resolvedPostcode)) {
             throw new InvalidInputError('DPD', this.country === 'DE'
                 ? 'DPD postcode must contain exactly 5 digits'

package/dist/carriers/gls-ch/adapter.d.ts

@@ -15,10 +15,16 @@ export declare class GLSSwitzerlandTrackingError extends NotFoundError {
     constructor();
 }
 export declare function normalizeGLSSwitzerlandTrackingNumber(raw: string): string;
-export declare function normalizeGLSSwitzerlandPostcode(raw: string, digits?: 4 | 5 | '4,5'): string;
+export type GLSPostcodeShape = 4 | 'any';
+/**
+ * The recipient postcode: four Swiss digits, or with `any` the postcode of any
+ * country GLS delivers in. GLS refuses only what no country writes, such as a
+ * symbol or fewer than three characters.
+ */
+export declare function normalizeGLSSwitzerlandPostcode(raw: string, shape?: GLSPostcodeShape): string;
 export declare function glsSwitzerlandTrackingUrl(rawTrackingNumber: string): string;
 export declare function glsSwitzerlandOverviewApiUrl(rawTrackingNumber: string, millis?: number): string;
-export declare function glsSwitzerlandDetailApiUrl(rawParcelNumber: string, rawPostcode: string, millis?: number, ownerCode?: string, postcodeDigits?: 4 | 5 | '4,5'): string;
+export declare function glsSwitzerlandDetailApiUrl(rawParcelNumber: string, rawPostcode: string, millis?: number, ownerCode?: string, postcodeShape?: GLSPostcodeShape): string;
 export declare function selectGLSParcel(payload: unknown, rawTrackingNumber: string): JsonObject;
 export declare function parseGLSSwitzerlandTrackingResponse(payload: unknown, rawTrackingNumber: string): CarrierResult;
 export declare class GLSSwitzerlandTracker {

package/dist/carriers/gls-ch/adapter.js

@@ -1,6 +1,7 @@
 import { load } from 'cheerio';
 import { DateTime } from 'luxon';
 import { lookupBudget } from '../../core/adapter/index.js';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
 import { InputRequiredError, InvalidInputError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -49,11 +50,16 @@ export function normalizeGLSSwitzerlandTrackingNumber(raw) {
     }
     return value;
 }
-export function normalizeGLSSwitzerlandPostcode(raw, digits = 4) {
-    const value = raw.trim();
-    if (!new RegExp(`^\\d{${digits}}$`).test(value)) {
-        const shape = `${digits === '4,5' ? '4- or 5' : digits}-digit recipient postcode`;
-        throw new InputRequiredError('GLS', `the ${shape}`, `GLS detailed tracking requires the ${shape}`);
+/**
+ * The recipient postcode: four Swiss digits, or with `any` the postcode of any
+ * country GLS delivers in. GLS refuses only what no country writes, such as a
+ * symbol or fewer than three characters.
+ */
+export function normalizeGLSSwitzerlandPostcode(raw, shape = 4) {
+    const value = shape === 'any' ? deliveryPostcodeText(raw) : raw.trim();
+    if (!(shape === 'any' ? DELIVERY_POSTCODE : /^\d{4}$/).test(value)) {
+        const wanted = shape === 'any' ? 'recipient postcode' : '4-digit recipient postcode';
+        throw new InputRequiredError('GLS', `the ${wanted}`, `GLS detailed tracking requires the ${wanted}`);
     }
     return value;
 }
@@ -70,7 +76,7 @@ export function glsSwitzerlandOverviewApiUrl(rawTrackingNumber, millis = Date.no
     url.searchParams.set('millis', String(millis));
     return url.toString();
 }
-export function glsSwitzerlandDetailApiUrl(rawParcelNumber, rawPostcode, millis = Date.now(), ownerCode = '', postcodeDigits = 4) {
+export function glsSwitzerlandDetailApiUrl(rawParcelNumber, rawPostcode, millis = Date.now(), ownerCode = '', postcodeShape = 4) {
     const parcelNumber = normalizeGLSSwitzerlandTrackingNumber(rawParcelNumber);
     if (!/^\d{11,14}$/.test(parcelNumber)) {
         throw new InputRequiredError('GLS', 'the numeric parcel number', 'GLS details require the numeric parcel number');
@@ -78,7 +84,7 @@ export function glsSwitzerlandDetailApiUrl(rawParcelNumber, rawPostcode, millis
     const url = new URL(`${TRACKING_API}/rstt028/${encodeURIComponent(parcelNumber)}`);
     url.searchParams.set('caller', 'witt002');
     url.searchParams.set('millis', String(millis));
-    url.searchParams.set('postalCode', normalizeGLSSwitzerlandPostcode(rawPostcode, postcodeDigits));
+    url.searchParams.set('postalCode', normalizeGLSSwitzerlandPostcode(rawPostcode, postcodeShape));
     const owner = text(ownerCode, 32);
     if (owner && /^[A-Z0-9_-]+$/i.test(owner))
         url.searchParams.set('tuOwnerCode', owner);

package/dist/carriers/gls-de/adapter.js

@@ -3,8 +3,9 @@ import { NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors
 import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { glsSwitzerlandDetailApiUrl, glsDeliveryReference, glsSwitzerlandOverviewApiUrl, GLSSwitzerlandTrackingError, normalizeGLSSwitzerlandPostcode, normalizeGLSSwitzerlandTrackingNumber, parseGLSSwitzerlandTrackingResponse, selectGLSParcel, } from '../gls-ch/adapter.js';
-// GLS's GROUP recipient service covers German and Swiss parcels. Keep the
-// shared response parser; the delivery postcode can be Swiss or German.
+// GLS's GROUP recipient service covers the parcels GLS delivers across its
+// network, so the delivery postcode can be any country's. Keep the shared
+// response parser.
 const PROVIDER = 'GLS Germany tracking';
 const CARRIER = 'GLS Germany';
 const DEFAULT_TIMEOUT_MS = 15_000;
@@ -33,7 +34,7 @@ export class GLSGermanyTracker {
     }
     async fetch(rawTrackingNumber, rawPostcode, context = {}) {
         const number = normalizeGLSSwitzerlandTrackingNumber(rawTrackingNumber);
-        const postcode = normalizeGLSSwitzerlandPostcode(rawPostcode, '4,5');
+        const postcode = normalizeGLSSwitzerlandPostcode(rawPostcode, 'any');
         // Two requests, each with the full request timeout.
         const budget = lookupBudget(context, 2 * this.timeoutMs);
         const overview = await this.request(glsSwitzerlandOverviewApiUrl(number, this.now()), budget);
@@ -55,7 +56,7 @@ export class GLSGermanyTracker {
         }
         const owners = Array.isArray(parcel.owners) ? parcel.owners.filter(isRecord) : [];
         const owner = owners.find((row) => row.type === 'REQUEST');
-        const detail = await this.request(glsSwitzerlandDetailApiUrl(String(parcel.tuNo), postcode, this.now(), cleanScalar(owner?.code, 64), '4,5'), budget);
+        const detail = await this.request(glsSwitzerlandDetailApiUrl(String(parcel.tuNo), postcode, this.now(), cleanScalar(owner?.code, 64), 'any'), budget);
         try {
             const result = parseGLSSwitzerlandTrackingResponse(detail, String(parcel.tuNo));
             // Both services use CET/CEST; expose the regional timezone to clients.

package/dist/carriers/gls-de/carrier.json

@@ -21,14 +21,13 @@
     "requirements": [
       {
         "field": "postcode",
-        "validator": "swissOrFrancePostcode",
+        "validator": "internationalPostcode",
         "label": "Delivery postcode",
         "type": "text",
-        "placeholder": "10115",
-        "help": "GLS requires the four- or five-digit delivery postcode to show the detailed event history.",
-        "pattern": "^[0-9]{4,5}$",
-        "maxLength": 5,
-        "inputMode": "numeric",
+        "help": "GLS requires the delivery postcode to show the detailed event history.",
+        "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+        "maxLength": 12,
+        "inputMode": "text",
         "autoComplete": "postal-code"
       }
     ],

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

@@ -5,11 +5,19 @@ import { TrawlClient } from '../../core/transport/index.js';
 import { MondialRelayAppClient } from './app.js';
 interface MondialRelayCredential {
     shipment: string;
+    /** The recipient's, as typed; empty when the number needs none. */
     postcode: string;
     canonicalShipment?: string;
     /** Read from a checksummed label barcode, which needs no postcode. */
     barcode?: true;
 }
+/**
+ * The shipment and the postcode Mondial Relay is asked with. The postcode is
+ * compared with the recipient's as typed, in any country's format: the country
+ * sent alongside only picks the reply's language. Only an 8-digit shipment
+ * needs it; the 10- and 12-digit forms carry the brand and are found without
+ * one, so a postcode typed for them is not sent.
+ */
 export declare function normalizeMondialRelayCredential(rawShipment: string, rawPostcode?: string): MondialRelayCredential;
 export declare function mondialRelayTrackingUrl(rawShipment: string, rawPostcode?: string): string;
 export declare function parseMondialRelayTrackingResponse(payload: unknown, rawShipment: string, rawPostcode?: string): CarrierResult;

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

@@ -1,5 +1,6 @@
 import { load } from 'cheerio';
 import { DateTime } from 'luxon';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
 import { isValidMondialRelayBarcode } from '../../core/detection/index.js';
 import { ChallengeError, InputRequiredError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
 import { runSteps, singleFlight, takeTurn } from '../../core/runner/index.js';
@@ -24,8 +25,8 @@ const DEFAULT_TIMEOUT_MS = 90_000;
 /** The app answers in about a second; past this the website gets the rest of the budget. */
 const DEFAULT_DIRECT_TIMEOUT_MS = 10_000;
 const ZONE = 'Europe/Paris';
-const CREDENTIAL_MESSAGE = 'Mondial Relay tracking requires an 8-, 10-, or 12-digit shipment number followed by '
-    + 'the 5-digit recipient postcode';
+const CREDENTIAL_MESSAGE = 'Mondial Relay tracking requires a 26-digit label barcode, a 10- or 12-digit shipment '
+    + 'number, or an 8-digit shipment number with the recipient postcode';
 /** Strip the markup Mondial Relay embeds in its labels, entities included. */
 function plainText(value, limit = 500) {
     if (typeof value !== 'string' && typeof value !== 'number')
@@ -36,32 +37,40 @@ function plainText(value, limit = 500) {
 function plausibleFrenchPostcode(value) {
     return /^(?:0[1-9]|[1-8]\d|9[0-5]|97|98)\d{3}$/.test(value);
 }
+/**
+ * The shipment and the postcode Mondial Relay is asked with. The postcode is
+ * compared with the recipient's as typed, in any country's format: the country
+ * sent alongside only picks the reply's language. Only an 8-digit shipment
+ * needs it; the 10- and 12-digit forms carry the brand and are found without
+ * one, so a postcode typed for them is not sent.
+ */
 export function normalizeMondialRelayCredential(rawShipment, rawPostcode = '') {
     let shipment = rawShipment.trim().replace(/[\s.-]/g, '');
-    let postcode = rawPostcode.trim();
+    let postcode = deliveryPostcodeText(rawPostcode);
     if (/^\d{26}$/.test(shipment)) {
-        if (!isValidMondialRelayBarcode(shipment) || (postcode && !plausibleFrenchPostcode(postcode))) {
+        if (!isValidMondialRelayBarcode(shipment) || (postcode && !DELIVERY_POSTCODE.test(postcode))) {
             throw new InvalidInputError('Mondial Relay', 'Invalid Mondial Relay barcode or postcode');
         }
         // The public alias carries brand/shipment/parcel sequence, not a postcode.
         return { shipment: shipment.slice(0, 12), postcode, canonicalShipment: shipment.slice(2, 10), barcode: true };
     }
     if (!postcode && /^(?:\d{13}|\d{15}|\d{17})$/.test(shipment)) {
+        // A French label prints the shipment followed by the 5-digit postcode.
+        if (!plausibleFrenchPostcode(shipment.slice(-5)))
+            throw new InvalidInputError('Mondial Relay', CREDENTIAL_MESSAGE);
         postcode = shipment.slice(-5);
         shipment = shipment.slice(0, -5);
     }
-    const shapedShipment = /^(?:\d{8}|\d{10}|\d{12})$/.test(shipment);
-    if (!shapedShipment || !plausibleFrenchPostcode(postcode)) {
-        // A well-shaped number without a usable postcode is a missing credential;
-        // anything else is a number this carrier cannot address at all.
-        throw shapedShipment
-            ? new InputRequiredError('Mondial Relay', 'the recipient postcode', CREDENTIAL_MESSAGE)
-            : new InvalidInputError('Mondial Relay', CREDENTIAL_MESSAGE);
+    if (!/^(?:\d{8}|\d{10}|\d{12})$/.test(shipment))
+        throw new InvalidInputError('Mondial Relay', CREDENTIAL_MESSAGE);
+    if (shipment.length === 8 && !DELIVERY_POSTCODE.test(postcode)) {
+        // A well-shaped number without a usable postcode is a missing credential.
+        throw new InputRequiredError('Mondial Relay', 'the recipient postcode', CREDENTIAL_MESSAGE);
     }
     // The longer forms put the 2-digit brand before the 8-digit shipment (the
     // 12-digit one adds the parcel sequence), and the API echoes the shipment.
     return shipment.length > 8
-        ? { shipment, postcode, canonicalShipment: shipment.slice(2, 10) }
+        ? { shipment, postcode: '', canonicalShipment: shipment.slice(2, 10) }
         : { shipment, postcode };
 }
 export function mondialRelayTrackingUrl(rawShipment, rawPostcode = '') {
@@ -75,6 +84,8 @@ function trackingApiUrl(credential, brand = '') {
     url.searchParams.set('shipment', credential.shipment);
     url.searchParams.set('postcode', credential.postcode);
     url.searchParams.set('brand', brand);
+    // Only the reply's language: the postcode matches whatever country it is from.
+    // The status and event parsers read French.
     url.searchParams.set('codePays', 'fr');
     return url.toString();
 }

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

@@ -5,7 +5,7 @@ export declare const MONDIAL_RELAY_APP_API = "https://mobile-app-bff.mondialrela
  * HTTP/2, and answers the same request over plain HTTP/1.1.
  */
 export declare const http1Fetch: typeof fetch;
-/** A normalized credential: 8, 10 or 12 digits, or a barcode's 12-digit alias, and a postcode. */
+/** A normalized credential: 8, 10 or 12 digits, or a barcode's 12-digit alias, and the postcode an 8-digit one needs. */
 export interface MondialRelayAppQuery {
     shipment: string;
     postcode: string;

package/dist/carriers/mondial-relay/carrier.json

@@ -22,15 +22,14 @@
     "requirements": [
       {
         "field": "postcode",
-        "whenTrackingNumber": "^(?![0-9]{26}$).*$",
-        "validator": "francePostcode",
+        "whenTrackingNumber": "^[0-9]{8}$",
+        "validator": "internationalPostcode",
         "label": "Delivery postcode",
         "type": "text",
-        "placeholder": "75001",
-        "help": "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.",
-        "pattern": "^[0-9]{5}$",
-        "maxLength": 5,
-        "inputMode": "numeric",
+        "help": "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.",
+        "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+        "maxLength": 12,
+        "inputMode": "text",
         "autoComplete": "postal-code"
       }
     ],

package/dist/core/catalog/inputs.js

@@ -3,6 +3,7 @@ import { activeRequirements, carrierDefinition } from './index.js';
 import { isValidMondialRelayBarcode } from '../detection/index.js';
 import { validateDachserTrackingUrl } from './urls.js';
 import { validatePlanzerSharedUrl } from './urls.js';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from './postcode.js';
 export { AUTOMATIC_CARRIER_IDS, CARRIER_NAMES, activeRequirements, carrierAdapter, carrierDefinition, carrierTimezone, requiredRequirements, } from './index.js';
 export { isValidS10TrackingNumber, supportsSwissPostHandoff, } from '../detection/index.js';
 export function normalizeCarrierInputs(carrierId, trackingNumber, trackingUrl, postcode) {
@@ -15,10 +16,13 @@ export function normalizeCarrierInputs(carrierId, trackingNumber, trackingUrl, p
         throw new TypeError('Invalid Mondial Relay barcode');
     }
     const requirements = new Map(activeRequirements(carrierId, trackingNumber).map((item) => [item.field, item]));
-    // Older clients may still supply a postcode for label barcodes. Validate it
-    // when present, while allowing the public alias to work without one.
-    if (mondialBarcode && supplied.postcode) {
-        requirements.set('postcode', { field: 'postcode', validator: 'francePostcode' });
+    // Older clients may still supply a postcode for Mondial Relay numbers that
+    // need none: label barcodes and the 10- and 12-digit forms. Validate it when
+    // present, while allowing them to work without one.
+    const mondialWithoutPostcode = mondialBarcode
+        || (carrierId === 'mondial-relay' && /^(?:\d{10}|\d{12})$/.test(trackingNumber));
+    if (mondialWithoutPostcode && supplied.postcode) {
+        requirements.set('postcode', { field: 'postcode', validator: 'internationalPostcode' });
     }
     for (const [field, value] of Object.entries(supplied)) {
         if (value !== null && !requirements.has(field)) {
@@ -76,10 +80,10 @@ export function normalizeCarrierInputs(carrierId, trackingNumber, trackingUrl, p
                 break;
             case 'internationalPostcode':
                 // The carrier delivers abroad too: any country's postcode, checked by the carrier itself.
-                if (!POSTCODE_SHAPE.test(postcodeText(value))) {
+                if (!DELIVERY_POSTCODE.test(deliveryPostcodeText(value))) {
                     throw new TypeError(`${carrierDefinition(carrierId).displayName} requires a valid delivery postcode`);
                 }
-                supplied[field] = postcodeText(value);
+                supplied[field] = deliveryPostcodeText(value);
                 break;
             case 'paackPostcode': {
                 const rawPostcode = value.toLocaleUpperCase('en-US');
@@ -95,15 +99,10 @@ export function normalizeCarrierInputs(carrierId, trackingNumber, trackingUrl, p
     }
     return supplied;
 }
-/** Any country's postcode: 3 to 12 characters with a digit, in groups joined by one space or hyphen. */
-const POSTCODE_SHAPE = /^(?=.{3,12}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/;
-function postcodeText(value) {
-    return value.trim().toUpperCase().replace(/\s+/g, ' ');
-}
 /** A recipient postcode for universal providers; independent of a carrier's own credentials. */
 export function normalizeDeliveryPostcode(value) {
-    const normalized = postcodeText(value);
-    if (!POSTCODE_SHAPE.test(normalized)) {
+    const normalized = deliveryPostcodeText(value);
+    if (!DELIVERY_POSTCODE.test(normalized)) {
         throw new TypeError('A valid delivery postcode is required');
     }
     return normalized;

package/dist/core/catalog/postcode.d.ts

@@ -0,0 +1,4 @@
+/** Any country's postcode: 3 to 12 characters with a digit, in groups joined by one space or hyphen. */
+export declare const DELIVERY_POSTCODE: RegExp;
+/** A typed postcode as it is checked and sent: trimmed, in capitals, with single spaces. */
+export declare function deliveryPostcodeText(value: string): string;

package/dist/core/catalog/postcode.js

@@ -0,0 +1,6 @@
+/** Any country's postcode: 3 to 12 characters with a digit, in groups joined by one space or hyphen. */
+export const DELIVERY_POSTCODE = /^(?=.{3,12}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/;
+/** A typed postcode as it is checked and sent: trimmed, in capitals, with single spaces. */
+export function deliveryPostcodeText(value) {
+    return value.trim().toUpperCase().replace(/\s+/g, ' ');
+}

package/dist/data/catalog.json

@@ -949,15 +949,14 @@
             "requirements": [
                 {
                     "field": "postcode",
-                    "whenTrackingNumber": "^(?![0-9]{26}$).*$",
-                    "validator": "francePostcode",
+                    "whenTrackingNumber": "^[0-9]{8}$",
+                    "validator": "internationalPostcode",
                     "label": "Delivery postcode",
                     "type": "text",
-                    "placeholder": "75001",
-                    "help": "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.",
-                    "pattern": "^[0-9]{5}$",
-                    "maxLength": 5,
-                    "inputMode": "numeric",
+                    "help": "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
                     "autoComplete": "postal-code"
                 }
             ]
@@ -1109,8 +1108,9 @@
         "timezone": "Europe/Paris",
         "tracking": {
             "mode": "automatic",
-            "adapter": "la-poste",
-            "recognitionRank": 45
+            "adapter": "chronopost",
+            "recognitionRank": 45,
+            "localClocks": true
         },
         "canaryUrl": "https://www.chronopost.fr/tracking-no-cms/suivi-page",
         "trackingUrlTemplate": "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}",
@@ -1644,14 +1644,13 @@
             "requirements": [
                 {
                     "field": "postcode",
-                    "validator": "swissOrFrancePostcode",
+                    "validator": "internationalPostcode",
                     "label": "Delivery postcode",
                     "type": "text",
-                    "placeholder": "10115",
-                    "help": "GLS requires the four- or five-digit delivery postcode to show the detailed event history.",
-                    "pattern": "^[0-9]{4,5}$",
-                    "maxLength": 5,
-                    "inputMode": "numeric",
+                    "help": "GLS requires the delivery postcode to show the detailed event history.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
                     "autoComplete": "postal-code"
                 }
             ],

package/dist/generated/catalog.d.ts

@@ -584,15 +584,14 @@ export declare const CARRIER_CATALOG: {
             readonly adapter: "mondial-relay";
             readonly requirements: readonly [{
                 readonly field: "postcode";
-                readonly whenTrackingNumber: "^(?![0-9]{26}$).*$";
-                readonly validator: "francePostcode";
+                readonly whenTrackingNumber: "^[0-9]{8}$";
+                readonly validator: "internationalPostcode";
                 readonly label: "Delivery postcode";
                 readonly type: "text";
-                readonly placeholder: "75001";
-                readonly help: "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.";
-                readonly pattern: "^[0-9]{5}$";
-                readonly maxLength: 5;
-                readonly inputMode: "numeric";
+                readonly help: "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.";
+                readonly pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$";
+                readonly maxLength: 12;
+                readonly inputMode: "text";
                 readonly autoComplete: "postal-code";
             }];
         };
@@ -691,8 +690,9 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "Europe/Paris";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "la-poste";
+            readonly adapter: "chronopost";
             readonly recognitionRank: 45;
+            readonly localClocks: true;
         };
         readonly canaryUrl: "https://www.chronopost.fr/tracking-no-cms/suivi-page";
         readonly trackingUrlTemplate: "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}";
@@ -1045,14 +1045,13 @@ export declare const CARRIER_CATALOG: {
             readonly adapter: "gls-de";
             readonly requirements: readonly [{
                 readonly field: "postcode";
-                readonly validator: "swissOrFrancePostcode";
+                readonly validator: "internationalPostcode";
                 readonly label: "Delivery postcode";
                 readonly type: "text";
-                readonly placeholder: "10115";
-                readonly help: "GLS requires the four- or five-digit delivery postcode to show the detailed event history.";
-                readonly pattern: "^[0-9]{4,5}$";
-                readonly maxLength: 5;
-                readonly inputMode: "numeric";
+                readonly help: "GLS requires the delivery postcode to show the detailed event history.";
+                readonly pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$";
+                readonly maxLength: 12;
+                readonly inputMode: "text";
                 readonly autoComplete: "postal-code";
             }];
             readonly recognitionRank: 50;

package/dist/generated/catalog.js

@@ -950,15 +950,14 @@ export const CARRIER_CATALOG = {
             "requirements": [
                 {
                     "field": "postcode",
-                    "whenTrackingNumber": "^(?![0-9]{26}$).*$",
-                    "validator": "francePostcode",
+                    "whenTrackingNumber": "^[0-9]{8}$",
+                    "validator": "internationalPostcode",
                     "label": "Delivery postcode",
                     "type": "text",
-                    "placeholder": "75001",
-                    "help": "Short Mondial Relay shipment numbers require the recipient postcode; validated 26-digit label barcodes do not.",
-                    "pattern": "^[0-9]{5}$",
-                    "maxLength": 5,
-                    "inputMode": "numeric",
+                    "help": "8-digit Mondial Relay shipment numbers require the recipient postcode; longer numbers and label barcodes do not.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
                     "autoComplete": "postal-code"
                 }
             ]
@@ -1110,8 +1109,9 @@ export const CARRIER_CATALOG = {
         "timezone": "Europe/Paris",
         "tracking": {
             "mode": "automatic",
-            "adapter": "la-poste",
-            "recognitionRank": 45
+            "adapter": "chronopost",
+            "recognitionRank": 45,
+            "localClocks": true
         },
         "canaryUrl": "https://www.chronopost.fr/tracking-no-cms/suivi-page",
         "trackingUrlTemplate": "https://www.chronopost.fr/tracking-no-cms/suivi-page?langue=fr&listeNumerosLT={trackingNumber}",
@@ -1645,14 +1645,13 @@ export const CARRIER_CATALOG = {
             "requirements": [
                 {
                     "field": "postcode",
-                    "validator": "swissOrFrancePostcode",
+                    "validator": "internationalPostcode",
                     "label": "Delivery postcode",
                     "type": "text",
-                    "placeholder": "10115",
-                    "help": "GLS requires the four- or five-digit delivery postcode to show the detailed event history.",
-                    "pattern": "^[0-9]{4,5}$",
-                    "maxLength": 5,
-                    "inputMode": "numeric",
+                    "help": "GLS requires the delivery postcode to show the detailed event history.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
                     "autoComplete": "postal-code"
                 }
             ],

package/dist/generated/registry.js

@@ -12,6 +12,7 @@ import { adapter as brt } from '../carriers/brt/adapter.js';
 import { adapter as cChezVous } from '../carriers/c-chez-vous/adapter.js';
 import { adapter as canadaPost } from '../carriers/canada-post/adapter.js';
 import { adapter as canpar } from '../carriers/canpar/adapter.js';
+import { adapter as chronopost } from '../carriers/chronopost/adapter.js';
 import { adapter as ciblex } from '../carriers/ciblex/adapter.js';
 import { adapter as cne } from '../carriers/cne/adapter.js';
 import { adapter as colisPrive } from '../carriers/colis-prive/adapter.js';
@@ -117,6 +118,7 @@ export const REGISTRY = {
         "c-chez-vous": cChezVous,
         "canada-post": canadaPost,
         "canpar": canpar,
+        "chronopost": chronopost,
         "ciblex": ciblex,
         "cne": cne,
         "colis-prive": colisPrive,
@@ -225,7 +227,7 @@ export const REGISTRY = {
         "canada-post": "canada-post",
         "canpar": "canpar",
         "china-post": "universal",
-        "chronopost": "la-poste",
+        "chronopost": "chronopost",
         "ciblex": "ciblex",
         "cne": "cne",
         "colis-prive": "colis-prive",

package/dist/server/openapi.json

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

package/package.json

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