universal-parcel-scraper 0.510.0-main.2413 → 0.511.0-main.2416

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 **554 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **555 dedicated adapters** and **5 universal fallbacks**
 
 <sub>772 catalog entries · 134 countries represented</sub>
 <!-- /GENERATED:summary -->

package/data/catalog.json

@@ -3123,7 +3123,7 @@
         "checksum": "luhn"
       },
       {
-        "pattern": "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
+        "pattern": "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
         "confidence": "high"
       }
     ]
@@ -23849,7 +23849,20 @@
     "timezone": "America/Toronto",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "postmedia-parcel-services",
+      "requirements": [
+        {
+          "field": "postcode",
+          "validator": "internationalPostcode",
+          "label": "Delivery postal code",
+          "type": "text",
+          "help": "Postmedia Parcel Services shows a parcel only with the recipient's postal code.",
+          "pattern": "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$",
+          "maxLength": 7,
+          "inputMode": "text",
+          "autoComplete": "postal-code"
+        }
+      ]
     },
     "canaryUrl": "https://postmediaparcelservices.com/",
     "trackingSearchUrl": "https://postmediaparcelservices.com/",
@@ -23859,7 +23872,7 @@
           "postmediaparcelservices.com",
           "www.postmediaparcelservices.com"
         ],
-        "pathPattern": "^/?$",
+        "pathPattern": "^/(?:fr/?)?(?:track-your-shipment/?)?$",
         "params": [
           "bniTrackingID"
         ]

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 772,
-  "activeAdapters": 554,
+  "activeAdapters": 555,
   "countries": 134,
   "referenceCarriers": 100,
   "comparison": {

package/data/detection-golden.json

@@ -64316,6 +64316,17 @@
       "ekart"
     ]
   },
+  {
+    "input": "BNI000000001",
+    "carrier": "unknown",
+    "confidence": "low",
+    "candidates": [
+      "colis-prive"
+    ],
+    "asked": [
+      "colis-prive"
+    ]
+  },
   {
     "input": "BOK2023192",
     "carrier": "bookurier",

package/dist/browser/scraper.js

@@ -2778,7 +2778,7 @@ var Ue = {
 				checksum: "luhn"
 			},
 			{
-				pattern: "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
+				pattern: "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
 				confidence: "high"
 			}
 		]
@@ -18087,13 +18087,24 @@ var Ue = {
 		timezone: "America/Toronto",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "postmedia-parcel-services",
+			requirements: [{
+				field: "postcode",
+				validator: "internationalPostcode",
+				label: "Delivery postal code",
+				type: "text",
+				help: "Postmedia Parcel Services shows a parcel only with the recipient's postal code.",
+				pattern: "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$",
+				maxLength: 7,
+				inputMode: "text",
+				autoComplete: "postal-code"
+			}]
 		},
 		canaryUrl: "https://postmediaparcelservices.com/",
 		trackingSearchUrl: "https://postmediaparcelservices.com/",
 		linkRules: [{
 			domains: ["postmediaparcelservices.com", "www.postmediaparcelservices.com"],
-			pathPattern: "^/?$",
+			pathPattern: "^/(?:fr/?)?(?:track-your-shipment/?)?$",
 			params: ["bniTrackingID"]
 		}],
 		detectionRules: []

package/dist/carriers/postmedia-parcel-services/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+/** The API the tracker on postmediaparcelservices.com asks for one number and postal code. */
+export declare const POSTMEDIA_API = "https://pmparcelservicesapi.postmediaparcelservices.com";
+/** The page's lookup: the number, a plus sign and the postal code, in the path. */
+export declare function postmediaQueryUrl(number: string, postcode: string): string;
+export declare class PostmediaTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+    });
+    private read;
+    fetch(raw: string, rawPostcode: string | null | undefined, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/postmedia-parcel-services/adapter.js

@@ -0,0 +1,68 @@
+import { ChallengeError, SchemaError, TransportError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
+import { normalizePostmediaNumber, normalizePostmediaPostcode, parsePostmedia, POSTMEDIA_MAX_BYTES, PROVIDER } from './parser.js';
+/** The API the tracker on postmediaparcelservices.com asks for one number and postal code. */
+export const POSTMEDIA_API = 'https://pmparcelservicesapi.postmediaparcelservices.com';
+const REDIRECTS = [301, 302, 303, 307, 308];
+// Bot checks a CDN or firewall could put in place of the reply.
+const CHALLENGE = /_cf_chl_opt|cf-turnstile|<title>\s*(?:Just a moment|Attention Required|Access Denied|Request blocked)|awswaf|captcha/i;
+// API Gateway's answer for a route it does not have.
+const NO_ROUTE = /"Missing Authentication Token"/;
+const DEFAULT_BUDGET_MS = 15_000;
+/** The page's lookup: the number, a plus sign and the postal code, in the path. */
+export function postmediaQueryUrl(number, postcode) {
+    return `${POSTMEDIA_API}/query/${encodeURIComponent(number)}+${encodeURIComponent(postcode)}`;
+}
+function json(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch (cause) {
+        if (CHALLENGE.test(body.slice(0, 64_000)))
+            throw new ChallengeError(PROVIDER, 'Postmedia Parcel Services answered with a browser check', { cause });
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned a reply that is not JSON', { cause });
+    }
+}
+export class PostmediaTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async read(number, postcode, signal, timeoutMs) {
+        const { response, bytes } = await fetchBounded(postmediaQueryUrl(number, postcode), { method: 'GET', signal, headers: {
+                Accept: 'application/json, text/plain, */*', 'User-Agent': userAgentOf(this.options.userAgent),
+            } }, { provider: PROVIDER, timeoutMs: Math.max(1, Math.floor(timeoutMs)), maxBytes: POSTMEDIA_MAX_BYTES, redirect: 'manual',
+            fetcher: this.options.fetcher, allowHttpStatuses: [...REDIRECTS, 403, 404, 410] });
+        // The page reads a missing parcel from a 200 reply; a redirect, a 404 or a missing route is a moved API.
+        const body = decodeText(bytes);
+        if (REDIRECTS.includes(response.status) || response.status === 404 || response.status === 410
+            || (response.status === 403 && NO_ROUTE.test(body.slice(0, 1_000)))) {
+            throw new TransportError(PROVIDER, 'Postmedia Parcel Services tracking lookup is unavailable', { status: response.status });
+        }
+        if (response.status === 403)
+            throw new ChallengeError(PROVIDER, 'Postmedia Parcel Services refused the lookup', { status: 403 });
+        return parsePostmedia(json(body), number);
+    }
+    async fetch(raw, rawPostcode, context = {}) {
+        const number = normalizePostmediaNumber(raw);
+        const postcode = normalizePostmediaPostcode(rawPostcode);
+        // A read that fails to reach the tracker, or hangs, is sent once more:
+        // the first try gets half of the budget.
+        return runSteps({ carrier: 'postmedia-parcel-services', budgetMs: context.budgetMs ?? DEFAULT_BUDGET_MS, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [
+            { id: 'direct', run: ({ signal, remainingMs }) => this.read(number, postcode, signal, firstAttemptMs(remainingMs)) },
+            networkRetryStep(({ signal, remainingMs }) => this.read(number, postcode, signal, remainingMs)),
+        ]);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new PostmediaTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
+    // The postal code is part of every lookup, so the adapter cannot recognize a number alone.
+    return {
+        id: 'postmedia-parcel-services', recordsSteps: true, steps: ['direct', 'retry'],
+        track: (input, context) => tracker.fetch(input.number, input.postcode, context),
+    };
+};

package/dist/carriers/postmedia-parcel-services/carrier.json

@@ -19,17 +19,65 @@
   "timezone": "America/Toronto",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "postmedia-parcel-services",
+    "requirements": [
+      {
+        "field": "postcode",
+        "validator": "internationalPostcode",
+        "label": "Delivery postal code",
+        "type": "text",
+        "help": "Postmedia Parcel Services shows a parcel only with the recipient's postal code.",
+        "pattern": "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$",
+        "maxLength": 7,
+        "inputMode": "text",
+        "autoComplete": "postal-code"
+      }
+    ],
+    "steps": [
+      "direct",
+      "retry"
+    ]
   },
-  "capabilities": [],
+  "capabilities": [
+    "history",
+    "location",
+    "delivered_at",
+    "eta"
+  ],
   "portal": {
     "searchUrl": "https://postmediaparcelservices.com/",
     "canaryUrl": "https://postmediaparcelservices.com/",
-    "shows": [],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "eta",
+      "order_date",
+      "pickup_point"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "eta",
+      "delivered_at",
+      "offset_timestamps"
+    ],
+    "discarded": [
+      "order_date",
+      "pickup_point"
+    ],
+    "unavailable": [
+      "provider_code",
+      "weight",
+      "service_name",
+      "sender_name",
+      "recipient_name",
+      "recipient_address",
+      "signatory",
+      "proof_of_delivery",
+      "delivery_partner"
+    ]
   },
   "links": [
     {
@@ -37,7 +85,7 @@
         "postmediaparcelservices.com",
         "www.postmediaparcelservices.com"
       ],
-      "pathPattern": "^/?$",
+      "pathPattern": "^/(?:fr/?)?(?:track-your-shipment/?)?$",
       "params": [
         "bniTrackingID"
       ]

package/dist/carriers/postmedia-parcel-services/numbers.json

@@ -1,5 +1,20 @@
 {
   "carrier": "postmedia-parcel-services",
-  "gap": "Its tracker's archived lookups all carry the recipient's postal code, and no other public source shows a whole number.",
-  "records": []
+  "records": [
+    {
+      "number": "BNI000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-10-19",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "colis-prive"
+        ]
+      },
+      "note": "Invented placeholder for BNI and nine digits; every archived lookup on the tracker also carries the recipient's postal code, so none is kept."
+    }
+  ]
 }

package/dist/carriers/postmedia-parcel-services/parser.d.ts

@@ -0,0 +1,23 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "Postmedia Parcel Services";
+export declare const POSTMEDIA_MAX_BYTES: number;
+/** A number for the tracker, in capitals as its page sends it; anything else is not one Postmedia Parcel Services issues. */
+export declare function normalizePostmediaNumber(raw: string): string;
+/**
+ * The recipient's postal code, which the tracker asks for with every number,
+ * in capitals as the page sends it. The page puts a space in the middle of a
+ * six-character code, so a Canadian one goes with a space after its first
+ * three characters, however it was typed. The tracker itself checks any
+ * other code.
+ */
+export declare function normalizePostmediaPostcode(raw: string | null | undefined): string;
+/**
+ * The tracker's reply for one number and postal code: the parcel's number,
+ * its expected delivery day and its scans, each with a town, a province and a
+ * message in English and French. A number and postal code it holds nothing
+ * under get `missing_error`, the page's "we don't have information for the
+ * package": a wrong number, a wrong postal code, or a parcel the sender has
+ * not announced yet. The parcel's order date, its record ids and the pickup
+ * point's address and description are never read.
+ */
+export declare function parsePostmedia(payload: unknown, raw: string): CarrierResult;

package/dist/carriers/postmedia-parcel-services/parser.js

@@ -0,0 +1,159 @@
+import { DateTime } from 'luxon';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InputRequiredError, InvalidInputError, NoHistoryError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { languageStageStatus } from '../../core/status/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { postmediaStage } from './status.js';
+export const PROVIDER = 'Postmedia Parcel Services';
+// A delivered parcel's reply is about a kilobyte.
+export const POSTMEDIA_MAX_BYTES = 256 * 1024;
+// `BNI` and nine digits, as the tracker's lookups show them.
+const NUMBER = /^BNI\d{9}$/;
+// A Canadian postal code without its space.
+const POSTCODE = /^[A-Z]\d[A-Z]\d[A-Z]\d$/;
+const CLOCK = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/;
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+// The reply for a number and postal code the tracker holds no parcel under.
+const NO_MATCH = /\bdid not match our records\b/i;
+const MAX_ROWS = 200;
+// The page writes a province's name for its code; a scan may give either.
+const PROVINCES = {
+    AB: 'Alberta', BC: 'British Columbia', MB: 'Manitoba', NB: 'New Brunswick', NL: 'Newfoundland and Labrador',
+    NS: 'Nova Scotia', NT: 'Northwest Territories', NU: 'Nunavut', ON: 'Ontario', PE: 'Prince Edward Island',
+    QC: 'Quebec', SK: 'Saskatchewan', YT: 'Yukon',
+};
+/** A number for the tracker, in capitals as its page sends it; anything else is not one Postmedia Parcel Services issues. */
+export function normalizePostmediaNumber(raw) {
+    const number = typeof raw === 'string' && raw.length <= 64 ? normalizeTrackingNumber(raw) : '';
+    if (!NUMBER.test(number))
+        throw new InvalidInputError(PROVIDER, 'Postmedia Parcel Services numbers are BNI and nine digits');
+    return number;
+}
+/**
+ * The recipient's postal code, which the tracker asks for with every number,
+ * in capitals as the page sends it. The page puts a space in the middle of a
+ * six-character code, so a Canadian one goes with a space after its first
+ * three characters, however it was typed. The tracker itself checks any
+ * other code.
+ */
+export function normalizePostmediaPostcode(raw) {
+    const typed = deliveryPostcodeText(raw ?? '');
+    if (!typed)
+        throw new InputRequiredError(PROVIDER, 'postcode', 'Postmedia Parcel Services shows a parcel only with the recipient\'s postal code');
+    if (!DELIVERY_POSTCODE.test(typed))
+        throw new InvalidInputError(PROVIDER, 'Postmedia Parcel Services requires a valid recipient postal code');
+    const compact = typed.replace(/[\s-]/g, '');
+    return POSTCODE.test(compact) ? `${compact.slice(0, 3)} ${compact.slice(3)}` : typed;
+}
+/** An optional text field; anything but a string is a changed reply. */
+function text(row, key, maxLength = 200) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'string')
+        throw new SchemaError(PROVIDER, `Postmedia Parcel Services returned an invalid ${key}`);
+    const cleaned = clean(value, maxLength);
+    // The page shows the text "null" as no message.
+    return cleaned.toLowerCase() === 'null' ? '' : cleaned;
+}
+/**
+ * A scan's `event_date_time`, written without an offset. The page says all
+ * its times are in GMT, and archived replies agree: read in any Canadian
+ * zone, their newest scans would come after the reply was captured.
+ */
+function scanTime(value) {
+    const match = CLOCK.exec(value);
+    const instant = match ? `${match[1]}T${match[2]}` : '';
+    const parsed = DateTime.fromISO(instant, { zone: 'UTC' });
+    // Luxon rolls 24:00:00 over to the next day; only a clock that reads back unchanged is kept.
+    if (!match || !parsed.isValid || parsed.toFormat("yyyy-MM-dd'T'HH:mm:ss") !== instant) {
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned an invalid scan time');
+    }
+    return { time: `${instant}Z`, at: parsed.toMillis() };
+}
+/** A scan's town and province, the province by name as the page writes it. */
+function placeOf(row) {
+    const town = text(row, 'event_city', 80);
+    const province = text(row, 'event_province', 60);
+    return [town, PROVINCES[province.toUpperCase()] ?? province].filter(Boolean).join(', ');
+}
+/** A scan, or null when it has no message in either language: the page shows "N/A" for it. */
+function projectRow(row, index) {
+    if (!isRecord(row))
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned an invalid scan');
+    const { time, at } = scanTime(text(row, 'event_date_time', 40));
+    const description = text(row, 'parcel_status_message') || text(row, 'parcel_status_message_french');
+    if (!description)
+        return null;
+    const location = placeOf(row);
+    const staged = postmediaStage(description);
+    const event = {
+        time,
+        ...(location ? { location } : {}),
+        description,
+        ...(staged ? { stage: staged.stage, stage_source: staged.source } : {}),
+    };
+    return { at, index, key: JSON.stringify([at, description, location]), event };
+}
+/** The expected delivery day, which the page shows as it is given. */
+function expectedDay(payload) {
+    const day = text(payload, 'expected_delivery_date', 32);
+    return DAY.test(day) && DateTime.fromISO(day, { zone: 'UTC' }).isValid ? day : null;
+}
+/**
+ * The tracker's reply for one number and postal code: the parcel's number,
+ * its expected delivery day and its scans, each with a town, a province and a
+ * message in English and French. A number and postal code it holds nothing
+ * under get `missing_error`, the page's "we don't have information for the
+ * package": a wrong number, a wrong postal code, or a parcel the sender has
+ * not announced yet. The parcel's order date, its record ids and the pickup
+ * point's address and description are never read.
+ */
+export function parsePostmedia(payload, raw) {
+    const number = normalizePostmediaNumber(raw);
+    if (!isRecord(payload))
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned an invalid reply');
+    if (Object.hasOwn(payload, 'missing_error')) {
+        if (typeof payload.missing_error === 'string' && NO_MATCH.test(payload.missing_error)) {
+            throw new NotFoundError(PROVIDER, 'Postmedia Parcel Services has no parcel under this number and postal code');
+        }
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services answered with an unknown notice');
+    }
+    if (typeof payload.tracking_id !== 'string')
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned a parcel without its number');
+    if (normalizeTrackingNumber(clean(payload.tracking_id, 64)) !== number) {
+        throw new IndeterminateError(PROVIDER, 'Postmedia Parcel Services answered for another parcel');
+    }
+    const rows = payload.statuses;
+    if (!Array.isArray(rows))
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned a parcel with invalid scans');
+    if (rows.length > MAX_ROWS)
+        throw new SchemaError(PROVIDER, 'Postmedia Parcel Services returned an oversized history');
+    const seen = new Set();
+    const scans = [];
+    rows.forEach((row, index) => {
+        const scan = projectRow(row, index);
+        if (!scan || seen.has(scan.key))
+            return;
+        seen.add(scan.key);
+        scans.push(scan);
+    });
+    if (!scans.length)
+        throw new NoHistoryError(PROVIDER);
+    // Newest first, as the page sorts them; the reply lists the oldest first, so a later row is newer on one clock.
+    const events = scans.sort((a, b) => b.at - a.at || b.index - a.index).map((scan) => scan.event);
+    const newest = events[0];
+    const current = events.find((event) => event.stage);
+    const stage = current?.stage;
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: current.stage_source } : {}),
+        last_status_text: newest.description,
+        last_update: newest.time,
+        expected_delivery: stage === 'delivered' ? null : expectedDay(payload),
+        ...(stage === 'delivered' ? { delivered_at: current.time } : {}),
+        events,
+    };
+}

package/dist/carriers/postmedia-parcel-services/status.d.ts

@@ -0,0 +1,7 @@
+import { type ClassifiedWording, type Stage } from '../../core/status/index.js';
+import { type CarrierStatusMap } from '../../core/status/statusMap.js';
+/** The stage the map gives a scan's message. */
+export declare function postmediaMappedStage(wording: string): Stage | undefined;
+/** A scan's stage: its message in the map, else the shared wording rules, else nothing. */
+export declare function postmediaStage(wording: string): ClassifiedWording | null;
+export declare const statusMap: CarrierStatusMap;

package/dist/carriers/postmedia-parcel-services/status.js

@@ -0,0 +1,35 @@
+import { classifyWording } from '../../core/status/index.js';
+import { normalizeStatusWording } from '../../core/status/statusMap.js';
+/**
+ * The tracker's scans carry no code, only a message in English and in French.
+ * The messages seen in replies are mapped, and the pickup message the page's
+ * script singles out; other wording falls to the shared rules.
+ */
+const WORDINGS = new Map([
+    // The seller's or marketplace's own scan, before the parcel reaches a Postmedia hub.
+    ['Shipment has left seller facility and is in transit', 'in_transit'],
+    ['L\'envoi a quitté l\'établissement du vendeur et est en transit', 'in_transit'],
+    ['Arrival Scan/Received Hub', 'accepted'], // The first scan at a Postmedia hub.
+    ['Scan d\'arrivée/centre de réception', 'accepted'],
+    ['Out for delivery', 'out_for_delivery'],
+    ['En cours de livraison', 'out_for_delivery'],
+    ['Delivered', 'delivered'],
+    ['Livré', 'delivered'],
+    ['Available for pickup', 'ready_for_pickup'],
+].map(([wording, stage]) => [normalizeStatusWording(wording), stage]));
+/** The stage the map gives a scan's message. */
+export function postmediaMappedStage(wording) {
+    return WORDINGS.get(normalizeStatusWording(wording));
+}
+/** A scan's stage: its message in the map, else the shared wording rules, else nothing. */
+export function postmediaStage(wording) {
+    const mapped = postmediaMappedStage(wording);
+    if (mapped)
+        return { stage: mapped, source: 'carrier_map' };
+    const worded = classifyWording(wording, 'in_transit');
+    return worded.source === 'none' ? null : worded;
+}
+export const statusMap = {
+    stage: (_code, wording) => postmediaMappedStage(wording),
+    gaps: [],
+};

package/dist/carriers/purolator/carrier.json

@@ -82,7 +82,7 @@
     },
     {
       "id": "purolator-2",
-      "pattern": "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
+      "pattern": "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
       "confidence": "high"
     }
   ]

package/dist/core/catalog/statusMaps.js

@@ -341,6 +341,7 @@ import { statusMap as postaSlovenije } from '../../carriers/posta-slovenije/stat
 import { statusMap as postaSrbije } from '../../carriers/posta-srbije/status.js';
 import { statusMap as postex } from '../../carriers/postex/status.js';
 import { statusMap as postlogistics } from '../../carriers/postlogistics/status.js';
+import { statusMap as postmediaParcelServices } from '../../carriers/postmedia-parcel-services/status.js';
 import { statusMap as posturinn } from '../../carriers/posturinn/status.js';
 import { statusMap as ppl } from '../../carriers/ppl/status.js';
 import { statusMap as precisionDeliveries } from '../../carriers/precision-deliveries/status.js';
@@ -535,7 +536,8 @@ export const STATUS_MAPS = {
     'pitney-bowes': pitneyBowes, 'pitt-ohio': pittOhio, 'pos-indonesia': posIndonesia,
     'post-luxembourg': postLuxembourg, 'posta-faroe': postaFaroe, 'posta-kenya': postaKenya, 'posta-north-macedonia': postaNorthMacedonia, 'posta-romana': postaRomana,
     'posta-shqiptare': postaShqiptare,
-    'posta-slovenije': postaSlovenije, 'posta-srbije': postaSrbije, postex, postlogistics, posturinn, ppl, 'precision-deliveries': precisionDeliveries,
+    'posta-slovenije': postaSlovenije, 'posta-srbije': postaSrbije, postex, postlogistics, 'postmedia-parcel-services': postmediaParcelServices,
+    posturinn, ppl, 'precision-deliveries': precisionDeliveries,
     'pro-carrier': proCarrier, proships, 'pts-worldwide-express': ptsWorldwideExpress, ptt, 'pullman-cargo': pullmanCargo, 'quantium-solutions': quantiumSolutions,
     'quicksilver-sa': quicksilverSa, quiqup, qwintry, raben, 'ram-hand-to-hand': ramHandToHand, redpack, redur, redx, relaytech,
     'rl-carriers': rlCarriers, roadrunner, 'royal-express-mm': royalExpressMm,

package/dist/data/catalog.json

@@ -3123,7 +3123,7 @@
                 "checksum": "luhn"
             },
             {
-                "pattern": "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
+                "pattern": "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
                 "confidence": "high"
             }
         ]
@@ -23849,7 +23849,20 @@
         "timezone": "America/Toronto",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "postmedia-parcel-services",
+            "requirements": [
+                {
+                    "field": "postcode",
+                    "validator": "internationalPostcode",
+                    "label": "Delivery postal code",
+                    "type": "text",
+                    "help": "Postmedia Parcel Services shows a parcel only with the recipient's postal code.",
+                    "pattern": "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$",
+                    "maxLength": 7,
+                    "inputMode": "text",
+                    "autoComplete": "postal-code"
+                }
+            ]
         },
         "canaryUrl": "https://postmediaparcelservices.com/",
         "trackingSearchUrl": "https://postmediaparcelservices.com/",
@@ -23859,7 +23872,7 @@
                     "postmediaparcelservices.com",
                     "www.postmediaparcelservices.com"
                 ],
-                "pathPattern": "^/?$",
+                "pathPattern": "^/(?:fr/?)?(?:track-your-shipment/?)?$",
                 "params": [
                     "bniTrackingID"
                 ]

package/dist/generated/catalog.d.ts

@@ -2110,7 +2110,7 @@ export declare const CARRIER_CATALOG: {
             readonly confidence: "low";
             readonly checksum: "luhn";
         }, {
-            readonly pattern: "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$";
+            readonly pattern: "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$";
             readonly confidence: "high";
         }];
     };
@@ -15256,13 +15256,24 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "America/Toronto";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "universal";
+            readonly adapter: "postmedia-parcel-services";
+            readonly requirements: readonly [{
+                readonly field: "postcode";
+                readonly validator: "internationalPostcode";
+                readonly label: "Delivery postal code";
+                readonly type: "text";
+                readonly help: "Postmedia Parcel Services shows a parcel only with the recipient's postal code.";
+                readonly pattern: "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$";
+                readonly maxLength: 7;
+                readonly inputMode: "text";
+                readonly autoComplete: "postal-code";
+            }];
         };
         readonly canaryUrl: "https://postmediaparcelservices.com/";
         readonly trackingSearchUrl: "https://postmediaparcelservices.com/";
         readonly linkRules: readonly [{
             readonly domains: readonly ["postmediaparcelservices.com", "www.postmediaparcelservices.com"];
-            readonly pathPattern: "^/?$";
+            readonly pathPattern: "^/(?:fr/?)?(?:track-your-shipment/?)?$";
             readonly params: readonly ["bniTrackingID"];
         }];
         readonly detectionRules: readonly [];

package/dist/generated/catalog.js

@@ -3124,7 +3124,7 @@ export const CARRIER_CATALOG = {
                 "checksum": "luhn"
             },
             {
-                "pattern": "^(?!(?:BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
+                "pattern": "^(?!(?:BNI|BYS|CUB|GWD|LTN|MPX|NZC|QSP|RWM|XLT))[A-Z]{3}\\d{9}$",
                 "confidence": "high"
             }
         ]
@@ -23850,7 +23850,20 @@ export const CARRIER_CATALOG = {
         "timezone": "America/Toronto",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "postmedia-parcel-services",
+            "requirements": [
+                {
+                    "field": "postcode",
+                    "validator": "internationalPostcode",
+                    "label": "Delivery postal code",
+                    "type": "text",
+                    "help": "Postmedia Parcel Services shows a parcel only with the recipient's postal code.",
+                    "pattern": "^[A-Za-z][0-9][A-Za-z] ?[0-9][A-Za-z][0-9]$",
+                    "maxLength": 7,
+                    "inputMode": "text",
+                    "autoComplete": "postal-code"
+                }
+            ]
         },
         "canaryUrl": "https://postmediaparcelservices.com/",
         "trackingSearchUrl": "https://postmediaparcelservices.com/",
@@ -23860,7 +23873,7 @@ export const CARRIER_CATALOG = {
                     "postmediaparcelservices.com",
                     "www.postmediaparcelservices.com"
                 ],
-                "pathPattern": "^/?$",
+                "pathPattern": "^/(?:fr/?)?(?:track-your-shipment/?)?$",
                 "params": [
                     "bniTrackingID"
                 ]

package/dist/generated/registry.js

@@ -396,6 +396,7 @@ import { adapter as posteItaliane } from '../carriers/poste-italiane/adapter.js'
 import { adapter as postex } from '../carriers/postex/adapter.js';
 import { adapter as posti } from '../carriers/posti/adapter.js';
 import { adapter as postlogistics } from '../carriers/postlogistics/adapter.js';
+import { adapter as postmediaParcelServices } from '../carriers/postmedia-parcel-services/adapter.js';
 import { adapter as postnord } from '../carriers/postnord/adapter.js';
 import { adapter as posturinn } from '../carriers/posturinn/adapter.js';
 import { adapter as ppl } from '../carriers/ppl/adapter.js';
@@ -952,6 +953,7 @@ export const REGISTRY = {
         "postex": postex,
         "posti": posti,
         "postlogistics": postlogistics,
+        "postmedia-parcel-services": postmediaParcelServices,
         "postnord": postnord,
         "posturinn": posturinn,
         "ppl": ppl,
@@ -1666,7 +1668,7 @@ export const REGISTRY = {
         "postex": "postex",
         "posti": "posti",
         "postlogistics": "postlogistics",
-        "postmedia-parcel-services": "universal",
+        "postmedia-parcel-services": "postmedia-parcel-services",
         "postnord": "postnord",
         "postplus": "universal",
         "posturinn": "posturinn",

package/dist/server/openapi.json

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

package/package.json

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