universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/postlogistics/numbers.json

@@ -0,0 +1,54 @@
+{
+  "carrier": "postlogistics",
+  "records": [
+    {
+      "number": "12345678-001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "observed_request",
+      "shapeConfirmed": "2026-09-30",
+      "expect": {
+        "carrier": "postlogistics",
+        "confidence": "high"
+      },
+      "note": "Invented reference showing the portal's eight-digit and three-digit segments."
+    },
+    {
+      "number": "12345678002",
+      "role": "quarantined",
+      "evidence": "synthetic",
+      "derivedFrom": "observed_request",
+      "shapeConfirmed": "2026-09-30",
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "postlogistics",
+          "gls-ch",
+          "gls-fr",
+          "gls-de",
+          "blue-dart",
+          "aramex"
+        ]
+      },
+      "note": "Invented compact shape for the recognition route; not a known shipment."
+    },
+    {
+      "number": "000000000000000000",
+      "role": "negative",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-10",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "bpost",
+          "ecoscooting"
+        ]
+      },
+      "note": "Invented placeholder used as a shape check. Filed under PostLogistics, which no rule claims."
+    }
+  ]
+}

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

@@ -0,0 +1,20 @@
+/**
+ * PostLogistics status vocabulary.
+ *
+ * Every history entry carries a three-letter `Status` code next to its
+ * free-text `Description`. Only the codes that decide the shipment's outcome
+ * are mapped; everything else stays `in_transit` and the description is left
+ * for the sync's wording classifier. The map is deliberately small: a wrong
+ * "delivered" is worse than a missing nuance.
+ *
+ * The adapter classifies the shipment, not each event: the endpoint gives one
+ * code per scan but no stage vocabulary, so events are returned without an
+ * explicit stage and the sync records them for review.
+ */
+import type { CarrierStatus } from '../../core/result/index.js';
+/** Codes that mean the parcel reached its recipient. */
+export declare const POSTLOGISTICS_DELIVERED_CODES: readonly ["DEL", "DLV", "POD", "SIG"];
+/** The code that means the shipment is announced but not yet moving. */
+export declare const POSTLOGISTICS_NOTIFIED_CODE = "NTF";
+/** The shipment status the newest history code implies. */
+export declare function postlogisticsStatus(code: string): CarrierStatus;

package/dist/carriers/postlogistics/status.js

@@ -0,0 +1,12 @@
+/** Codes that mean the parcel reached its recipient. */
+export const POSTLOGISTICS_DELIVERED_CODES = ['DEL', 'DLV', 'POD', 'SIG'];
+/** The code that means the shipment is announced but not yet moving. */
+export const POSTLOGISTICS_NOTIFIED_CODE = 'NTF';
+/** The shipment status the newest history code implies. */
+export function postlogisticsStatus(code) {
+    if (POSTLOGISTICS_DELIVERED_CODES.includes(code))
+        return 'delivered';
+    if (code === POSTLOGISTICS_NOTIFIED_CODE)
+        return 'pending';
+    return 'in_transit';
+}

package/dist/carriers/postlogistics/statuses.json

@@ -0,0 +1,40 @@
+{
+  "carrier": "postlogistics",
+  "entries": [
+    {
+      "code": "DEL",
+      "stage": "delivered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Delivery confirmed."
+    },
+    {
+      "code": "DLV",
+      "stage": "delivered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Delivery confirmed."
+    },
+    {
+      "code": "POD",
+      "stage": "delivered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Proof of delivery recorded; the proof itself is never retained."
+    },
+    {
+      "code": "SIG",
+      "stage": "delivered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Signed for; the signature itself is never retained."
+    },
+    {
+      "code": "NTF",
+      "stage": "registered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment announced. The adapter reports the shipment as pending and stamps no event stage."
+    }
+  ]
+}

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

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

package/dist/carriers/postnord/adapter.js

@@ -0,0 +1,76 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { BudgetExceededError, IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { normalizePostnordNumber, parsePostnord } from './parser.js';
+const ENDPOINT = 'https://api2.postnord.com/rest/shipment/v1/trackingweb/shipmentInformation';
+const ORIGIN = 'https://tracking.postnord.com';
+// Reproduce the bounded anonymous request proof from the official widget:
+// https://tracking.postnord.com/widget-v2/pn-widget.mjs
+async function requestProof(number, signal, deadline, budgetMs) {
+    for (let attempt = 0; attempt < 100_000; attempt += 1) {
+        signal.throwIfAborted();
+        if (performance.now() >= deadline)
+            throw new BudgetExceededError('PostNord', budgetMs);
+        const nonce = randomUUID();
+        const digest = createHash('sha512').update(number + nonce).digest();
+        if (digest[0] === 0)
+            return Buffer.concat([digest, Buffer.from(`--${nonce}`)]).toString('base64');
+        // Let cancellation and deadline timers run during an unusually long search.
+        if (attempt % 128 === 127)
+            await new Promise((resolve) => setImmediate(resolve));
+    }
+    throw new IndeterminateError('PostNord', 'PostNord request proof could not be generated');
+}
+export class PostnordTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizePostnordNumber(raw);
+        const budgetMs = context.budgetMs ?? 15_000;
+        return runSteps({ carrier: 'postnord', budgetMs, signal: context.signal, recorder: this.options.recorder ?? NOOP_RECORDER }, [{
+                id: 'direct', run: async ({ signal, remainingMs }) => {
+                    const deadline = performance.now() + remainingMs;
+                    const proof = await requestProof(number, signal, deadline, budgetMs);
+                    signal.throwIfAborted();
+                    const left = deadline - performance.now();
+                    if (left <= 0)
+                        throw new BudgetExceededError('PostNord', budgetMs);
+                    const url = new URL(ENDPOINT);
+                    url.searchParams.set('shipmentId', number);
+                    url.searchParams.set('locale', 'en');
+                    url.searchParams.set('timeZone', 'UTC');
+                    const { response, bytes } = await fetchBounded(url.href, { signal, headers: {
+                            Accept: 'application/json', Origin: ORIGIN, 'x-bap-key': 'web-tracking-sc', 'X-CustomHeader': proof,
+                        } }, { provider: 'PostNord', timeoutMs: Math.max(1, Math.floor(left)), maxBytes: 1_000_000,
+                        allowHttpStatuses: [404, 410], fetcher: this.options.fetcher });
+                    if (response.status === 404 || response.status === 410) {
+                        let negative;
+                        try {
+                            negative = parseJsonBytes(bytes, 'PostNord');
+                        }
+                        catch { /* A generic error page proves no parcel negative. */ }
+                        if (response.status === 404 && isRecord(negative) && negative.message === 'Shipment was not found.')
+                            throw new NotFoundError('PostNord');
+                        throw new IndeterminateError('PostNord', 'PostNord returned an unrecognized missing-resource response');
+                    }
+                    let payload;
+                    try {
+                        payload = parseJsonBytes(bytes, 'PostNord');
+                    }
+                    catch (cause) {
+                        throw new SchemaError('PostNord', 'PostNord returned invalid shipment JSON', { cause });
+                    }
+                    return parsePostnord(payload, number);
+                },
+            }]);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new PostnordTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'postnord', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/postnord/carrier.json

@@ -0,0 +1,82 @@
+{
+  "id": "postnord",
+  "displayName": "PostNord",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "SE",
+      "DK",
+      "NO",
+      "FI"
+    ]
+  },
+  "brand": {
+    "color": "#00a0d6"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "postnord",
+    "steps": [
+      "direct"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "weight",
+    "dimensions"
+  ],
+  "portal": {
+    "url": "https://tracking.postnord.com/en/?id={trackingNumber}",
+    "canaryUrl": "https://tracking.postnord.com/en/",
+    "shows": [
+      "status",
+      "history",
+      "weight",
+      "dimensions",
+      "recipient",
+      "sender"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "weight",
+      "dimensions"
+    ],
+    "discarded": [
+      "recipient",
+      "sender"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "tracking.postnord.com"
+      ],
+      "params": [
+        "id",
+        "ID"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "postnord-1",
+      "pattern": "^\\d{11}SE$",
+      "confidence": "high"
+    },
+    {
+      "id": "postnord-2",
+      "pattern": "^[A-Z]{2}\\d{9}(?:SE|DK)$",
+      "confidence": "high",
+      "checksum": "s10"
+    },
+    {
+      "id": "postnord-3",
+      "pattern": "^00\\d(?:57|73|70|64)\\d{15}$",
+      "confidence": "low"
+    }
+  ]
+}

package/dist/carriers/postnord/numbers.json

@@ -0,0 +1,66 @@
+{
+  "carrier": "postnord",
+  "records": [
+    {
+      "number": "00573132901903503247",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6aa18ce5ceeb19b7855a6717",
+        "date": "2026-09-09"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "postnord",
+          "usps",
+          "nz-post",
+          "poczta-polska"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to PostNord, which stays one candidate among several."
+    },
+    {
+      "number": "84971563697SE",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/apoex/postnord"
+      },
+      "expect": {
+        "carrier": "postnord",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "RR123815032SE",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6aa0642b73c446456c716614",
+        "date": "2026-09-08"
+      },
+      "expect": {
+        "carrier": "postnord",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    },
+    {
+      "number": "UO820761246SE",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6ab411ce25125859f760401f",
+        "date": "2026-09-23"
+      },
+      "expect": {
+        "carrier": "postnord",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    }
+  ]
+}

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

@@ -0,0 +1,3 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizePostnordNumber(raw: string): string;
+export declare function parsePostnord(payload: unknown, number: string): CarrierResult;

package/dist/carriers/postnord/parser.js

@@ -0,0 +1,75 @@
+import { isValidS10TrackingNumber } from '../../core/detection/s10.js';
+import { IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyPostnordStatus, isPostnordAdministrativeEvent } from './status.js';
+export function normalizePostnordNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^\d{10,20}$/.test(number) && !/^\d{11}SE$/.test(number) && !isValidS10TrackingNumber(number)) {
+        throw new TypeError('PostNord requires a numeric or postal tracking number');
+    }
+    return number;
+}
+export function parsePostnord(payload, number) {
+    const requested = normalizePostnordNumber(number);
+    if (!isRecord(payload) || payload.shipmentId !== requested || payload.actualReturnedId !== requested
+        || !Array.isArray(payload.items) || payload.items.length > 100 || !payload.items.every(isRecord)) {
+        throw new SchemaError('PostNord', 'PostNord returned a different shipment or an unsupported shipment reference');
+    }
+    const matches = payload.items.filter((item) => item.itemId === requested);
+    if (matches.length !== 1)
+        throw new SchemaError('PostNord', 'PostNord did not return one matching item');
+    const item = matches[0];
+    if (!isRecord(item.status) || !clean(item.status.code, 64) || !Array.isArray(item.events) || item.events.length > 500) {
+        throw new SchemaError('PostNord');
+    }
+    const scans = [];
+    const seen = new Set();
+    for (const raw of item.events) {
+        if (!isRecord(raw))
+            throw new SchemaError('PostNord', 'PostNord returned an incomplete scan row');
+        const description = clean(raw.eventDescription, 500);
+        const code = clean(raw.status, 64);
+        const rawTime = clean(raw.eventTime, 64);
+        const time = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):?[0-5]\d)$/.test(rawTime)
+            ? explicitOffsetTime(rawTime) : null;
+        if (!description || !code || !time)
+            throw new SchemaError('PostNord', 'PostNord returned a scan without valid wording, code or offset timestamp');
+        // These confirmed notices describe messages or recipient choices rather
+        // than parcel movement. A notification "delivered" is not a delivery scan.
+        if (isPostnordAdministrativeEvent(code, description))
+            continue;
+        const location = isRecord(raw.location) ? clean(raw.location.name, 160) : '';
+        const key = `${time.timestamp}\u0000${code}\u0000${description}\u0000${location}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const mapped = classifyPostnordStatus(code, description);
+        scans.push({ timestamp: time.timestamp, event: { time: time.iso, description, provider_code: code,
+                ...(location ? { location } : {}), ...(mapped ? { stage: mapped.stage } : {}) } });
+    }
+    if (!scans.length)
+        throw new IndeterminateError('PostNord', 'PostNord returned no shipment history');
+    // The endpoint's ascending history is displayed newest first by the widget.
+    // Compare instants rather than ISO text so mixed offsets stay in order.
+    scans.sort((a, b) => b.timestamp - a.timestamp);
+    const events = scans.map((scan) => scan.event);
+    const header = clean(item.status.header, 500);
+    const mapped = classifyPostnordStatus(clean(item.status.code, 64), header);
+    const measurements = Array.isArray(item.measurements) ? item.measurements.filter(isRecord) : [];
+    const measured = (name, units) => {
+        const values = measurements.filter((measurement) => measurement.name === name && typeof measurement.value === 'number'
+            && Number.isFinite(measurement.value) && measurement.value > 0 && units.includes(clean(measurement.unit, 16)));
+        return values.length === 1 ? values[0] : null;
+    };
+    const weight = measured('weight', ['kg', 'g']);
+    const dimensions = ['length', 'width', 'height'].map((name) => measured(name, ['cm']));
+    const delivery = mapped?.status === 'delivered' ? events.find((event) => event.stage === 'delivered') : undefined;
+    return { status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        last_status_text: header || events[0].description, last_update: events[0].time,
+        expected_delivery: null, ...(delivery?.time ? { delivered_at: delivery.time } : {}),
+        ...(weight ? { weight_kg: weight.value / (weight.unit === 'g' ? 1000 : 1) } : {}),
+        ...(dimensions.every(Boolean) ? { dimensions_text: `${dimensions.map((dimension) => dimension.value).join(' × ')} cm` } : {}),
+        events: events.slice(0, 100) };
+}

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

@@ -0,0 +1,3 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function isPostnordAdministrativeEvent(code: string, description: string): boolean;
+export declare function classifyPostnordStatus(code: string, description?: string): ClassifiedStatus | undefined;

package/dist/carriers/postnord/status.js

@@ -0,0 +1,38 @@
+// Codes and their labels come from the official tracking widget. EN_ROUTE and
+// OTHER also cover several distinct milestones and administrative notices.
+const codes = {
+    CREATED: { status: 'pending', stage: 'registered' },
+    INFORMED: { status: 'pending', stage: 'registered' },
+    EN_ROUTE: { status: 'in_transit', stage: 'in_transit' },
+    AVAILABLE_FOR_DELIVERY: { status: 'in_transit', stage: 'ready_for_pickup' },
+    DELIVERED: { status: 'delivered', stage: 'delivered' },
+    DELIVERY_IMPOSSIBLE: { status: 'exception', stage: 'failed_attempt' },
+    DELIVERY_REFUSED: { status: 'exception', stage: 'failed_attempt' },
+    RETURNED: { status: 'exception', stage: 'returned' },
+    DELAYED: { status: 'exception', stage: 'exception' },
+    STOPPED: { status: 'exception', stage: 'exception' },
+    CUSTOMS_STOPPED_VAT: { status: 'exception', stage: 'customs' },
+};
+export function isPostnordAdministrativeEvent(code, description) {
+    return code === 'OTHER' && [
+        'Suggested delivery time.',
+        'Information to the driver added by the recipient.',
+        'A text message notification has been delivered to the recipient.',
+        'Notification sent via APP.',
+    ].includes(description);
+}
+export function classifyPostnordStatus(code, description = '') {
+    if (code === 'EN_ROUTE' || code === 'OTHER') {
+        if (description === 'The delivery of the shipment item is in progress.') {
+            return { status: 'out_for_delivery', stage: 'out_for_delivery' };
+        }
+        if ([
+            'The shipment item is under transportation.',
+            'The shipment item has arrived at the distribution terminal.',
+            'Your item is being processed at our sorting center.',
+            'The shipment item has been loaded.',
+        ].includes(description))
+            return { status: 'in_transit', stage: 'in_transit' };
+    }
+    return codes[code];
+}

package/dist/carriers/postnord/statuses.json

@@ -0,0 +1,16 @@
+{
+  "carrier": "postnord",
+  "entries": [
+    { "code": "INFORMED", "wording": "We have received a notification from your shipper that they are preparing an item for you. The tracking information will be updated when the parcel is handed over to PostNord.", "language": "en", "stage": "registered", "confirmedBy": "live" },
+    { "code": "EN_ROUTE", "wording": "The shipment item is under transportation.", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "EN_ROUTE", "wording": "The shipment item has arrived at the distribution terminal.", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "EN_ROUTE", "wording": "The delivery of the shipment item is in progress.", "language": "en", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "OTHER", "wording": "The shipment item is under transportation.", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "OTHER", "wording": "Your item is being processed at our sorting center.", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "OTHER", "wording": "The shipment item has been loaded.", "language": "en", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "DELIVERY_IMPOSSIBLE", "wording": "Delivery was not possible. The recipient will get a notification with information on where the shipment item will be available for collection.", "language": "en", "stage": "failed_attempt", "confirmedBy": "live" },
+    { "code": "AVAILABLE_FOR_DELIVERY", "wording": "The shipment item has been delivered to a service point.", "language": "en", "stage": "ready_for_pickup", "confirmedBy": "live" },
+    { "code": "DELIVERED", "wording": "The shipment item has been delivered.", "language": "en", "stage": "delivered", "confirmedBy": "live" },
+    { "code": "DELIVERED", "wording": "The shipment item has been delivered to the recipient's mailbox.", "language": "en", "stage": "delivered", "confirmedBy": "live" }
+  ]
+}

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

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

package/dist/carriers/purolator/adapter.js

@@ -0,0 +1,45 @@
+import { ChallengeError, IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { normalizePurolatorNumber, parsePurolator } from './parser.js';
+const ENDPOINT = 'https://public-tracking.purolator.com/tracking/data';
+// Public anonymous client configuration, not an account/API credential:
+// https://web.purolator.com/app/tracker/js/app.tracker-drupal.js
+const PUBLIC_WIDGET_KEY = 'NneqHVQEJO5CkHcsiPXqJ8cTAngvBR1D3Rcu3baQ'; // gitleaks:allow
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36';
+export class PurolatorTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizePurolatorNumber(raw);
+        return runSteps({ carrier: 'purolator', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    signal.throwIfAborted();
+                    const { response, bytes } = await fetchBounded(ENDPOINT, { method: 'POST', signal,
+                        headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'User-Agent': USER_AGENT, 'x-api-key': PUBLIC_WIDGET_KEY },
+                        body: JSON.stringify({ search: [{ trackingId: number, sequenceId: 1, eventSortOrder: 'd' }], language: 'en' }),
+                    }, { provider: 'Purolator', timeoutMs: Math.max(1, Math.floor(remainingMs)), maxBytes: 1_000_000,
+                        allowHttpStatuses: [404, 405, 410], fetcher: this.options.fetcher });
+                    if ([202, 405].includes(response.status) && ['captcha', 'challenge'].includes(response.headers.get('x-amzn-waf-action') ?? '')) {
+                        throw new ChallengeError('Purolator', 'Purolator requires an AWS WAF challenge');
+                    }
+                    if (response.status !== 200)
+                        throw new IndeterminateError('Purolator', 'Purolator returned an unrecognized tracking response');
+                    let payload;
+                    try {
+                        payload = parseJsonBytes(bytes, 'Purolator');
+                    }
+                    catch (cause) {
+                        throw new SchemaError('Purolator', 'Purolator returned invalid tracking JSON', { cause });
+                    }
+                    return parsePurolator(payload, number);
+                } }]);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new PurolatorTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'purolator', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/purolator/carrier.json

@@ -0,0 +1,75 @@
+{
+  "id": "purolator",
+  "displayName": "Purolator",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "CA"
+    ]
+  },
+  "brand": {
+    "color": "#da291c"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "purolator",
+    "steps": [
+      "direct"
+    ],
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "weight"
+  ],
+  "portal": {
+    "url": "https://www.purolator.com/en/shipping/tracker?pins={trackingNumber}",
+    "canaryUrl": "https://www.purolator.com/en/shipping/tracker",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "estimated_delivery",
+      "weight",
+      "recipient"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "weight"
+    ],
+    "discarded": [
+      "estimated_delivery",
+      "recipient"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "purolator.com"
+      ],
+      "params": [
+        "searchValue",
+        "pin",
+        "pins"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "purolator-1",
+      "pattern": "^[0-5]\\d{11}$",
+      "confidence": "low"
+    },
+    {
+      "id": "purolator-2",
+      "pattern": "^(?!(?:BYS|LTN))[A-Z]{3}\\d{9}$",
+      "confidence": "high"
+    }
+  ]
+}