universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/swiss-post-cargo/status.js

@@ -0,0 +1,53 @@
+/**
+ * Swiss Post Cargo status classification.
+ *
+ * The public endpoint returns a short `Status` code plus a free-text
+ * `Description` in the shipment's language (de/fr/it/en). Only a handful of
+ * codes have a confirmed meaning, so wording is consulted first for the
+ * outcomes that must never be guessed wrong (returns and failures), and the
+ * codes settle the rest.
+ */
+import { cleanScalar } from '../../core/transport/index.js';
+/** Lower-cased, accent-free wording, for language-independent matching. */
+export function comparable(value) {
+    return cleanScalar(value)
+        .toLocaleLowerCase('de-CH')
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '');
+}
+/**
+ * Confirmed codes (observed on the public tracker, 2026-08-30): DLV/POD/P40/
+ * IMG/SIG accompany a delivery, SCA a delivery-round scan, NTF an
+ * announcement, RFS an acceptance. Everything else stays in transit.
+ */
+export function statusFor(code, description) {
+    const normalizedCode = code.toLocaleUpperCase('en-US');
+    const text = comparable(description);
+    if (['retour', 'return', 'zuruck'].some((term) => text.includes(term))) {
+        return { status: 'exception', stage: 'returned' };
+    }
+    if (['incident', 'refuse', 'damage'].some((term) => text.includes(term))) {
+        return { status: 'exception', stage: 'exception' };
+    }
+    if (['echec', 'failed', 'not delivered', 'non livre', 'nicht zugestellt', 'verzoger']
+        .some((term) => text.includes(term))) {
+        return { status: 'exception', stage: 'failed_attempt' };
+    }
+    if (['DLV', 'POD', 'P40', 'IMG', 'SIG'].includes(normalizedCode)
+        || ['delivered', 'livre', 'zugestellt', 'consegnat'].some((term) => text.includes(term))) {
+        return { status: 'delivered', stage: 'delivered' };
+    }
+    if (['out for delivery', 'en livraison', 'in zustellung', 'in consegna']
+        .some((term) => text.includes(term))) {
+        return { status: 'out_for_delivery', stage: 'out_for_delivery' };
+    }
+    if (normalizedCode === 'SCA') {
+        return { status: 'out_for_delivery', stage: 'out_for_delivery' };
+    }
+    if (normalizedCode === 'NTF'
+        || ['annonce', 'registered', 'angemeldet', 'information received']
+            .some((term) => text.includes(term))) {
+        return { status: 'pending', stage: 'registered' };
+    }
+    return { status: 'in_transit', stage: normalizedCode === 'RFS' ? 'accepted' : 'in_transit' };
+}

package/dist/carriers/swiss-post-cargo/statuses.json

@@ -0,0 +1,19 @@
+{
+  "carrier": "swiss-post-cargo",
+  "entries": [
+    { "code": "DLV", "stage": "delivered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Delivery scan; appears with the wording 'Delivered'." },
+    { "code": "POD", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Proof-of-delivery family carried over from the adapter's original map; not re-confirmed against a capture." },
+    { "code": "P40", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Proof-of-delivery family carried over from the adapter's original map; not re-confirmed against a capture." },
+    { "code": "IMG", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Proof-of-delivery family carried over from the adapter's original map; not re-confirmed against a capture." },
+    { "code": "SIG", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Proof-of-delivery family carried over from the adapter's original map; not re-confirmed against a capture." },
+    { "code": "SCA", "stage": "out_for_delivery", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Delivery-round scan." },
+    { "code": "NTF", "stage": "registered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Shipment announced." },
+    { "code": "RFS", "stage": "accepted", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Accompanies the wording 'Shipment accepted'." },
+    { "wording": "retour / return / zurück", "language": "mul", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Wording rule; wins over any delivery word in the same row." },
+    { "wording": "échec / failed / not delivered / non livré / nicht zugestellt / verzögert", "language": "mul", "stage": "failed_attempt", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule; 'Not delivered' is covered by the offline test." },
+    { "wording": "incident / refusé / damage", "language": "mul", "stage": "exception", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Wording rule; a carrier-reported problem, not a missed attempt. Reclassified to exception 2026-09-12." },
+    { "wording": "delivered / livré / zugestellt / consegnato", "language": "mul", "stage": "delivered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule, consulted after the negative rules above." },
+    { "wording": "out for delivery / en livraison / in Zustellung / in consegna", "language": "mul", "stage": "out_for_delivery", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Wording rule." },
+    { "wording": "annoncé / registered / angemeldet / information received", "language": "mul", "stage": "registered", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Wording rule." }
+  ]
+}

package/dist/carriers/thailand-post/carrier.json

@@ -0,0 +1,38 @@
+{
+  "id": "thailand-post",
+  "displayName": "Thailand Post",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "TH"
+    ]
+  },
+  "brand": {
+    "color": "#ef172f"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "universal",
+    "steps": []
+  },
+  "capabilities": [],
+  "portal": {
+    "url": "https://international.thailandpost.com/track-status?lang=en",
+    "canaryUrl": "https://t.17track.net/",
+    "shows": [],
+    "scraped": [],
+    "discarded": [],
+    "unavailable": []
+  },
+  "links": [],
+  "detection": [
+    {
+      "id": "thailand-post-1",
+      "pattern": "^[A-Z]{2}\\d{9}TH$",
+      "confidence": "high",
+      "checksum": "s10"
+    }
+  ]
+}

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

@@ -0,0 +1,33 @@
+{
+  "carrier": "thailand-post",
+  "records": [
+    {
+      "number": "EE138961080TH",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://gist.github.com/zxp/e83a4a1b7294a5ed6207",
+        "date": "2015-08-29"
+      },
+      "expect": {
+        "carrier": "thailand-post",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "WB371672691TH",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://pantip.com/topic/44231379",
+        "date": "2026-09-18"
+      },
+      "expect": {
+        "carrier": "thailand-post",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. Domestic item."
+    }
+  ]
+}

package/dist/carriers/the-courier-guy/adapter.d.ts

@@ -0,0 +1,11 @@
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class CourierGuyTracker {
+    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/the-courier-guy/adapter.js

@@ -0,0 +1,49 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { decodeText, fetchBounded } from '../../core/transport/index.js';
+import { normalizeCourierGuyNumber, normalizeCourierGuyRecognitionNumber, parseCourierGuy } from './parser.js';
+const ENDPOINT = 'https://api.portal.thecourierguy.co.za/tracking/shipments';
+export class CourierGuyTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizeCourierGuyNumber(raw);
+        return runSteps({ carrier: 'the-courier-guy', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    signal.throwIfAborted();
+                    const url = new URL(ENDPOINT);
+                    url.searchParams.set('tracking_reference', number);
+                    // Public provider identity returned by /providers for the official portal.
+                    url.searchParams.set('provider_id', '7');
+                    const { response, bytes } = await fetchBounded(url, { signal, headers: { Accept: 'application/json' } }, {
+                        provider: 'The Courier Guy', timeoutMs: Math.max(1, Math.floor(remainingMs)), maxBytes: 1_000_000,
+                        allowHttpStatuses: [404, 410], fetcher: this.options.fetcher,
+                    });
+                    const body = decodeText(bytes);
+                    if (response.status === 404) {
+                        if (body === `could not find shipment or parcel with reference ${number}`)
+                            throw new NotFoundError('The Courier Guy');
+                        throw new IndeterminateError('The Courier Guy', 'Tracking endpoint unavailable');
+                    }
+                    if (response.status === 410)
+                        throw new IndeterminateError('The Courier Guy', 'Tracking endpoint unavailable');
+                    let payload;
+                    try {
+                        payload = JSON.parse(body);
+                    }
+                    catch {
+                        throw new SchemaError('The Courier Guy');
+                    }
+                    return parseCourierGuy(payload, number);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new CourierGuyTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'the-courier-guy', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeCourierGuyRecognitionNumber(number))) };
+};

package/dist/carriers/the-courier-guy/carrier.json

@@ -0,0 +1,73 @@
+{
+  "id": "the-courier-guy",
+  "displayName": "The Courier Guy",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "ZA"
+    ]
+  },
+  "brand": {
+    "color": "#264796"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "the-courier-guy",
+    "steps": [
+      "direct"
+    ],
+    "recognition": {
+      "rank": 29
+    },
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "delivered_at"
+  ],
+  "portal": {
+    "url": "https://portal.thecourierguy.co.za/track?ref={trackingNumber}",
+    "canaryUrl": "https://portal.thecourierguy.co.za/track",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "eta"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "delivered_at"
+    ],
+    "discarded": [
+      "messages",
+      "contact_details",
+      "proof_images",
+      "eta"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "portal.thecourierguy.co.za",
+        "track.thecourierguy.co.za"
+      ],
+      "path": "^/track/?$",
+      "params": [
+        "ref"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "the-courier-guy-1",
+      "pattern": "^(?:DD|LD)[A-Z0-9]{6}$",
+      "confidence": "low"
+    }
+  ]
+}

package/dist/carriers/the-courier-guy/number.d.ts

@@ -0,0 +1,3 @@
+/** Native product formatting shared by API requests and tracking links. */
+export declare function normalizeCourierGuyNumber(raw: string): string;
+export declare function normalizeCourierGuyRecognitionNumber(raw: string): string;

package/dist/carriers/the-courier-guy/number.js

@@ -0,0 +1,18 @@
+/** Native product formatting shared by API requests and tracking links. */
+export function normalizeCourierGuyNumber(raw) {
+    const number = raw.replace(/\s/g, '').toUpperCase();
+    // The native client preserves this product separator. Generic input
+    // normalization removes dashes, so restore only the confirmed label forms.
+    const product = /^(DD|LD)-?([A-Z0-9]{6})$/.exec(number);
+    if (product)
+        return `${product[1]}-${product[2]}`;
+    if (!/^[A-Z0-9]{5,40}$/.test(number))
+        throw new TypeError('The Courier Guy requires a shipment tracking reference');
+    return number;
+}
+export function normalizeCourierGuyRecognitionNumber(raw) {
+    const number = normalizeCourierGuyNumber(raw);
+    if (!/^(?:DD|LD)-[A-Z0-9]{6}$/.test(number))
+        throw new TypeError('The Courier Guy recognition requires a supported product reference');
+    return number;
+}

package/dist/carriers/the-courier-guy/numbers.json

@@ -0,0 +1,74 @@
+{
+  "carrier": "the-courier-guy",
+  "records": [
+    {
+      "number": "37DDNQ",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.hellopeter.com/the-courier-guy/reviews/this-company-has-lost-its-way-i-am-done-6589583",
+        "date": "2026-09-09"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to The Courier Guy; no rule matches this shape."
+    },
+    {
+      "number": "DD-KBA6JL",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.hellopeter.com/the-courier-guy/reviews/no-collection-no-call-refusing-refund-dd-kba6jl-6597318",
+        "date": "2026-09-14"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "gls-ch",
+          "gls-fr",
+          "gls-de",
+          "the-courier-guy"
+        ]
+      },
+      "note": "Publicly reported cancelled collection reference with identity-bound history in the official anonymous feed."
+    },
+    {
+      "number": "LD-2C7WLM",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.hellopeter.com/the-courier-guy/reviews/courier-guy-is-the-worst-service-provider-6590204",
+        "date": "2026-09-10"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "gls-ch",
+          "gls-fr",
+          "gls-de",
+          "the-courier-guy"
+        ]
+      },
+      "note": "Publicly reported Pudo locker-to-door reference with identity-bound history in the official anonymous feed."
+    },
+    {
+      "number": "QGB8C",
+      "role": "order_reference",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.consumercomplaints.in/bycompany/the-courier-guy-south-africa-a266527.html",
+        "date": "2022-03-18"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. Short reference from the source; standalone tracking is unconfirmed. The source attributes it to The Courier Guy; no rule matches this shape."
+    }
+  ]
+}

package/dist/carriers/the-courier-guy/parser.d.ts

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

package/dist/carriers/the-courier-guy/parser.js

@@ -0,0 +1,104 @@
+import { DateTime } from 'luxon';
+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 { courierGuyStatus, courierGuyWording, HIDDEN_COURIER_GUY_CODES } from './status.js';
+import { normalizeCourierGuyNumber } from './number.js';
+export { normalizeCourierGuyNumber, normalizeCourierGuyRecognitionNumber } from './number.js';
+function clock(value) {
+    if (value != null && typeof value !== 'string')
+        throw new SchemaError('The Courier Guy', 'Invalid scan clock');
+    const raw = clean(value, 64);
+    const base = '^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d{1,9})?';
+    if (new RegExp(`${base}(?:Z|[+-](?:0\\d|1[0-3]):?[0-5]\\d|[+-]14:?00)$`).test(raw)) {
+        const instant = explicitOffsetTime(raw);
+        if (instant)
+            return { time: instant.iso };
+    }
+    if (new RegExp(`${base}$`).test(raw)) {
+        const wall = DateTime.fromISO(raw, { zone: 'UTC' });
+        if (wall.isValid)
+            return { local_time: wall.toISO({ includeOffset: false }) };
+    }
+    return raw ? { provider_time_text: raw } : {};
+}
+export function parseCourierGuy(payload, rawNumber) {
+    const number = normalizeCourierGuyNumber(rawNumber);
+    if (!isRecord(payload) || !Array.isArray(payload.shipments))
+        throw new SchemaError('The Courier Guy');
+    if (!payload.shipments.length)
+        throw new IndeterminateError('The Courier Guy', 'No identity-bound shipment history');
+    if (payload.shipments.length !== 1)
+        throw new IndeterminateError('The Courier Guy', 'Ambiguous shipment match');
+    const shipment = payload.shipments[0];
+    if (!isRecord(shipment) || shipment.provider_id !== 7
+        || typeof shipment.short_tracking_reference !== 'string' || !/^[A-Z0-9]{5,40}$/.test(shipment.short_tracking_reference)
+        || (shipment.short_tracking_reference !== number
+            && (!/^(?:DD|LD)-[A-Z0-9]{6}$/.test(number) || shipment.custom_tracking_reference !== number))) {
+        throw new SchemaError('The Courier Guy', 'Different carrier or shipment reference');
+    }
+    if (typeof shipment.status !== 'string' || !/^[a-z0-9-]{1,64}$/.test(shipment.status)
+        || !Array.isArray(shipment.tracking_events) || shipment.tracking_events.length > 500)
+        throw new SchemaError('The Courier Guy');
+    // Cancelled, never-collected DD bookings omit their count. This bounded
+    // precollection timeline cannot complete a delivered or moving shipment.
+    const cancelledCollection = shipment.parcel_count == null && shipment.status === 'cancelled'
+        && typeof shipment.custom_tracking_reference === 'string' && /^DD-[A-Z0-9]{6}$/.test(shipment.custom_tracking_reference)
+        && Array.isArray(shipment.parcel_tracking_references)
+        && shipment.parcel_tracking_references.length === 1
+        && shipment.tracking_events.every(row => isRecord(row) && row.parcel_id === 0
+            && ['submitted', 'collection-assigned', 'collection-failed-attempt', 'cancelled'].includes(String(row.status)));
+    if (!Array.isArray(shipment.parcel_tracking_references)
+        || !shipment.parcel_tracking_references.length
+        || shipment.parcel_tracking_references.length > 500
+        || shipment.parcel_tracking_references.some(ref => typeof ref !== 'string'
+            || (!/^[A-Z0-9]{5,40}$/.test(ref) && !(cancelledCollection && ref === `${shipment.custom_tracking_reference}/1`)))
+        || new Set(shipment.parcel_tracking_references).size !== shipment.parcel_tracking_references.length)
+        throw new SchemaError('The Courier Guy', 'Invalid shipment pieces');
+    if (!cancelledCollection && (!Number.isSafeInteger(shipment.parcel_count) || shipment.parcel_count < 1
+        || shipment.parcel_tracking_references.length !== shipment.parcel_count))
+        throw new SchemaError('The Courier Guy', 'Invalid shipment pieces');
+    const events = [];
+    for (const row of shipment.tracking_events) {
+        if (!isRecord(row) || !Number.isSafeInteger(row.parcel_id) || row.parcel_id < 0
+            || typeof row.status !== 'string' || !/^[a-z0-9-]{1,64}$/.test(row.status)
+            || (row.location != null && typeof row.location !== 'string'))
+            throw new SchemaError('The Courier Guy', 'Invalid shipment scan');
+        // parcel_id=0 is the shipment timeline used by the official consumer page.
+        // A delivered individual piece cannot complete the whole shipment.
+        if (row.parcel_id !== 0 || HIDDEN_COURIER_GUY_CODES.has(row.status))
+            continue;
+        const mapped = courierGuyStatus(row.status);
+        events.push({ ...clock(row.date), provider_code: row.status, description: courierGuyWording(row.status),
+            location: clean(row.location, 200), ...(mapped ? { stage: mapped.stage } : {}) });
+    }
+    if (!events.length)
+        throw new IndeterminateError('The Courier Guy', 'No public shipment scans');
+    const latest = events[0];
+    const hiddenSummary = HIDDEN_COURIER_GUY_CODES.has(shipment.status);
+    if (!hiddenSummary && shipment.status !== latest.provider_code) {
+        throw new IndeterminateError('The Courier Guy', 'Shipment summary does not match the latest scan');
+    }
+    // For hidden summaries the consumer chooses its public current scan by date.
+    // Preserve backend order only when it cannot contradict that selection.
+    if (hiddenSummary && events.some(event => !event.time)) {
+        throw new IndeterminateError('The Courier Guy', 'No dated public current scan');
+    }
+    if (latest.time) {
+        const currentMillis = DateTime.fromISO(latest.time).toMillis();
+        if (events.some(event => event.time && (DateTime.fromISO(event.time).toMillis() > currentMillis
+            || (hiddenSummary && DateTime.fromISO(event.time).toMillis() === currentMillis && event.provider_code !== latest.provider_code)))) {
+            throw new IndeterminateError('The Courier Guy', 'Ambiguous public current scan order');
+        }
+    }
+    const mapped = courierGuyStatus(latest.provider_code);
+    const seen = new Set();
+    const unique = events.filter(event => { const key = JSON.stringify(event); if (seen.has(key))
+        return false; seen.add(key); return true; });
+    return { status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        ...(shipment.short_tracking_reference !== number ? { canonical_tracking_number: shipment.short_tracking_reference } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null, last_update_local: latest.local_time ?? null,
+        expected_delivery: null, ...(mapped?.status === 'delivered' && latest.time ? { delivered_at: latest.time } : {}),
+        events: unique.slice(0, 100) };
+}

package/dist/carriers/the-courier-guy/status.d.ts

@@ -0,0 +1,5 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function courierGuyStatus(code: string): ClassifiedStatus | undefined;
+/** The consumer page hides operational events from the shipment timeline. */
+export declare const HIDDEN_COURIER_GUY_CODES: Set<string>;
+export declare function courierGuyWording(code: string): string;

package/dist/carriers/the-courier-guy/status.js

@@ -0,0 +1,21 @@
+const groups = [
+    [['submitted', 'pending-approval', 'collection-assigned', 'awaiting-dropoff', 'collection-accepted'], { status: 'pending', stage: 'registered' }],
+    [['collected'], { status: 'in_transit', stage: 'accepted' }],
+    [['at-hub', 'manifested', 'ready-for-dispatch', 'in-transit', 'at-destination-hub', 'returned-to-hub',
+            'delivery-assigned', 'delivery-scheduled', 'outsourced', 'collect-and-return-to-hub', 'return-to-hub'], { status: 'in_transit', stage: 'in_transit' }],
+    [['out-for-delivery'], { status: 'out_for_delivery', stage: 'out_for_delivery' }],
+    [['ready-for-pickup', 'in-locker'], { status: 'in_transit', stage: 'ready_for_pickup' }],
+    [['delivered', 'collected-from-locker', 'collected-from-counter'], { status: 'delivered', stage: 'delivered' }],
+    [['returned-to-sender'], { status: 'exception', stage: 'returned' }],
+    [['cancelled', 'collection-exception', 'collection-failed-attempt', 'delivery-exception', 'delivery-failed-attempt',
+            'inbound-customs-and-vat', 'on-hold', 'undeliverable', 'under-query', 'damaged'], { status: 'exception', stage: 'exception' }],
+];
+const codes = new Map(groups.flatMap(([names, status]) => names.map(name => [name, status])));
+export function courierGuyStatus(code) { return codes.get(code); }
+/** The consumer page hides operational events from the shipment timeline. */
+export const HIDDEN_COURIER_GUY_CODES = new Set(['bob-box-reservation-failed', 'on-hold-internal', 'delivery-rejected',
+    'delivery-unassigned', 'collection-rejected', 'collection-unassigned', 'collection-accepted',
+    'bob-box-dropoff-pin-revealed', 'operational-event']);
+export function courierGuyWording(code) {
+    return code === 'delivered' ? 'Delivered' : code.replaceAll('-', ' ').replace(/^./, letter => letter.toUpperCase());
+}

package/dist/carriers/the-courier-guy/statuses.json

@@ -0,0 +1,61 @@
+{
+  "carrier": "the-courier-guy",
+  "entries": [
+    {
+      "code": "submitted",
+      "wording": "submitted",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "collection-assigned",
+      "wording": "collection-assigned",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "collected",
+      "wording": "collected",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "at-hub",
+      "wording": "at-hub",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "in-transit",
+      "wording": "in-transit",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "at-destination-hub",
+      "wording": "at-destination-hub",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "ready-for-pickup",
+      "wording": "ready-for-pickup",
+      "language": "en",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "delivered",
+      "wording": "delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    }
+  ]
+}

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

@@ -0,0 +1,12 @@
+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 TipsaTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;