universal-parcel-scraper 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,29 @@
+/**
+ * Colisweb: the anonymous search endpoint behind colisweb.com/suivi-livraison.
+ *
+ * One bounded POST per lookup ('direct' step). Colisweb schedules appointed
+ * deliveries for retailers, so its response is about a delivery slot rather than
+ * a parcel journey: it carries the retailer's name, the recipient block and the
+ * booked time window next to three milestone timestamps. `parse()` keeps the
+ * milestones, the step and the slot's starting day; everything describing a
+ * person or a shop is dropped.
+ */
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export { classifyStatus } from './status.js';
+export declare function normalizeColiswebTrackingNumber(raw: string): string;
+export declare function coliswebTrackingUrl(): string;
+export declare function coliswebRequestBody(rawTrackingNumber: string): string;
+export declare function parseColiswebTrackingResponse(payload: unknown, rawTrackingNumber: string): CarrierResult;
+export interface ColiswebTrackerOptions {
+    timeoutMs?: number;
+    /** Test seam; production uses the global fetch. */
+    fetcher?: typeof fetch;
+}
+export declare class ColiswebTracker {
+    #private;
+    readonly timeoutMs: number;
+    constructor(options?: ColiswebTrackerOptions);
+    fetch(rawTrackingNumber: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/colisweb/adapter.js

@@ -0,0 +1,166 @@
+/**
+ * Colisweb: the anonymous search endpoint behind colisweb.com/suivi-livraison.
+ *
+ * One bounded POST per lookup ('direct' step). Colisweb schedules appointed
+ * deliveries for retailers, so its response is about a delivery slot rather than
+ * a parcel journey: it carries the retailer's name, the recipient block and the
+ * booked time window next to three milestone timestamps. `parse()` keeps the
+ * milestones, the step and the slot's starting day; everything describing a
+ * person or a shop is dropped.
+ */
+import { IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { UpstreamHttpError, clean, decodeText, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyStatus } from './status.js';
+export { classifyStatus } from './status.js';
+const PROVIDER = 'Colisweb';
+const TRACKING_ENDPOINT = 'https://www.colisweb.com/api/search';
+const TIMEZONE = 'Europe/Paris';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 500_000;
+const NOT_FOUND_PATTERN = /not[ -]?found|introuvable|inconnu/i;
+/**
+ * The endpoint sends ISO 8601 timestamps with their own offset, so they are kept
+ * verbatim rather than restamped. Anything `Date.parse` refuses is dropped.
+ */
+function normalizedTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const candidate = clean(value, 64);
+    return candidate && !Number.isNaN(Date.parse(candidate)) ? candidate : null;
+}
+function normalizedDate(value) {
+    const timestamp = normalizedTimestamp(value);
+    if (!timestamp)
+        return null;
+    const match = /^(\d{4}-\d{2}-\d{2})/.exec(timestamp);
+    return match?.[1] ?? new Date(timestamp).toISOString().slice(0, 10);
+}
+function saysNotFound(value) {
+    if (!isRecord(value))
+        return false;
+    const text = [value.error, value.message, value.texteErreur]
+        .filter((part) => typeof part === 'string')
+        .join(' ');
+    return /not[ -]?found|introuvable|inconnu|aucun(?:e)? livraison/i.test(text);
+}
+export function normalizeColiswebTrackingNumber(raw) {
+    const value = raw.replace(/\s/g, '');
+    if (!/^\d{8,32}$/.test(value)) {
+        throw new TypeError('Colisweb tracking numbers must contain at least 8 digits');
+    }
+    return value;
+}
+export function coliswebTrackingUrl() {
+    return TRACKING_ENDPOINT;
+}
+export function coliswebRequestBody(rawTrackingNumber) {
+    return JSON.stringify({ value: normalizeColiswebTrackingNumber(rawTrackingNumber) });
+}
+export function parseColiswebTrackingResponse(payload, rawTrackingNumber) {
+    const trackingNumber = normalizeColiswebTrackingNumber(rawTrackingNumber);
+    if (saysNotFound(payload))
+        throw new NotFoundError(PROVIDER);
+    if (!isRecord(payload))
+        throw new SchemaError(PROVIDER, 'Colisweb returned an invalid tracking response');
+    const responseNumber = typeof payload.searchValue === 'string'
+        ? payload.searchValue.replace(/\s/g, '')
+        : '';
+    if (!/^\d{8,32}$/.test(responseNumber)) {
+        throw new SchemaError(PROVIDER, 'Colisweb returned incomplete tracking details');
+    }
+    if (responseNumber !== trackingNumber) {
+        throw new SchemaError(PROVIDER, 'Colisweb returned a different shipment');
+    }
+    const current = classifyStatus(payload.step);
+    const milestones = [
+        {
+            value: payload.deliveredDate,
+            classified: classifyStatus('delivered'),
+        },
+        {
+            value: payload.pickedUpDate,
+            classified: classifyStatus('pickedUp'),
+        },
+        {
+            value: payload.deliveryConfirmationDate,
+            classified: classifyStatus('confirmed'),
+        },
+    ];
+    const events = milestones.flatMap(({ value, classified }) => {
+        const time = normalizedTimestamp(value);
+        return time ? [{ time, description: classified.description, stage: classified.stage }] : [];
+    });
+    if (!events.some((event) => event.stage === current.stage)) {
+        // An unmapped step carries no stage, so the sync classifies this entry.
+        events.unshift({
+            description: current.description,
+            ...(current.stage ? { stage: current.stage } : {}),
+        });
+    }
+    const lastUpdate = events.find((event) => event.time)?.time ?? null;
+    return {
+        status: current.status,
+        ...(current.stage ? { current_stage: current.stage } : {}),
+        last_status_text: current.description,
+        last_update: lastUpdate,
+        expected_delivery: ['delivered', 'exception'].includes(current.status)
+            ? null
+            : normalizedDate(payload.startsAt),
+        timezone: TIMEZONE,
+        events,
+    };
+}
+export class ColiswebTracker {
+    timeoutMs;
+    #fetcher;
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new TypeError('Colisweb timeout must be positive');
+        }
+        this.#fetcher = options.fetcher;
+    }
+    async fetch(rawTrackingNumber) {
+        const trackingNumber = normalizeColiswebTrackingNumber(rawTrackingNumber);
+        const { response, bytes } = await fetchBounded(coliswebTrackingUrl(), {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                Origin: 'https://www.colisweb.com',
+                Referer: 'https://www.colisweb.com/suivi-livraison',
+                'User-Agent': 'Mozilla/5.0 (compatible; DeliveryTracker/1.0)',
+            },
+            body: coliswebRequestBody(trackingNumber),
+        }, {
+            provider: 'Colisweb tracking',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_RESPONSE_BYTES,
+            redirect: 'error',
+            allowHttpError: true,
+            fetcher: this.#fetcher,
+        });
+        if ([400, 404, 422].includes(response.status))
+            throw new NotFoundError(PROVIDER);
+        if (response.status === 500 && bytes.byteLength === 0) {
+            // The official UI turns this empty HTTP 500 into its not-found card, but the
+            // response itself proves nothing: reporting it as a 404 would invent a fact.
+            throw new IndeterminateError(PROVIDER, 'Colisweb returned an empty HTTP 500 for the shipment lookup');
+        }
+        if (!response.ok) {
+            if (NOT_FOUND_PATTERN.test(decodeText(bytes)))
+                throw new NotFoundError(PROVIDER);
+            throw new UpstreamHttpError('Colisweb tracking', response.status);
+        }
+        return parseColiswebTrackingResponse(parseJsonBytes(bytes, 'Colisweb tracking'), trackingNumber);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new ColiswebTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'colisweb',
+        steps: ['direct'],
+        track: (input) => tracker.fetch(input.number),
+    };
+};

package/dist/carriers/colisweb/carrier.json

@@ -0,0 +1,63 @@
+{
+  "id": "colisweb",
+  "displayName": "Colisweb",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "FR"
+    ]
+  },
+  "brand": {
+    "color": "#ff8a00"
+  },
+  "selectable": true,
+  "timezone": "Europe/Paris",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "colisweb",
+    "steps": [
+      "direct"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "eta"
+  ],
+  "portal": {
+    "url": "https://www.colisweb.com/suivi-livraison?value={trackingNumber}",
+    "canaryUrl": "https://www.colisweb.com/suivi-livraison",
+    "shows": [
+      "status",
+      "history",
+      "eta",
+      "eta_window",
+      "sender_name",
+      "recipient_name",
+      "recipient_address"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "eta"
+    ],
+    "discarded": [
+      "eta_window",
+      "sender_name",
+      "recipient_name",
+      "recipient_address"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "colisweb.com"
+      ],
+      "params": [
+        "value",
+        "trackingNumber"
+      ]
+    }
+  ],
+  "detection": []
+}

package/dist/carriers/colisweb/numbers.json

@@ -0,0 +1,39 @@
+{
+  "carrier": "colisweb",
+  "records": [
+    {
+      "number": "11854362",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/69d652f26c2dbef5f8ee61fb",
+        "date": "2026-04-08"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "mondial-relay",
+          "heppner"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to Colisweb, which no rule claims."
+    },
+    {
+      "number": "87654321",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-10",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "mondial-relay",
+          "heppner"
+        ]
+      },
+      "note": "Invented placeholder used as a shape check. Filed under Colisweb, which no rule claims."
+    }
+  ]
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Colisweb delivery steps.
+ *
+ * The anonymous search endpoint reports one machine step per delivery (`step`)
+ * and no wording. Steps arrive in several spellings across the provider's own
+ * surfaces (`pickedUp`, `picked_up`, `PICKED_UP`), so they are compared with
+ * case and separators removed. The French descriptions below are ours: Colisweb
+ * sends none.
+ *
+ * A step that is not listed stays unmapped — the adapter reports the delivery
+ * with no stage and the sync classifies it.
+ */
+import type { CarrierStatus } from '../../core/result/index.js';
+import type { Stage } from '../../generated/catalog.js';
+export interface ClassifiedStatus {
+    status: CarrierStatus;
+    /** Absent when the step is unknown: the sync's classifier decides instead. */
+    stage?: Stage;
+    description: string;
+}
+/** Lowercase and drop everything that is not a letter or a digit. */
+export declare function statusKey(value: unknown): string;
+export declare const DELIVERED_STEPS: readonly string[];
+export declare const RETURNED_STEPS: readonly string[];
+export declare const CANCELED_STEPS: readonly string[];
+/** A carrier-reported problem that is neither a missed attempt nor a return. */
+export declare const EXCEPTION_STEPS: readonly string[];
+export declare const FAILED_STEPS: readonly string[];
+export declare const OUT_FOR_DELIVERY_STEPS: readonly string[];
+export declare const PICKED_UP_STEPS: readonly string[];
+export declare const CONFIRMED_STEPS: readonly string[];
+export declare function classifyStatus(value: unknown): ClassifiedStatus;

package/dist/carriers/colisweb/status.js

@@ -0,0 +1,61 @@
+/** Lowercase and drop everything that is not a letter or a digit. */
+export function statusKey(value) {
+    return typeof value === 'string'
+        ? value.toLocaleLowerCase('en-US').replace(/[^a-z0-9]+/g, '')
+        : '';
+}
+export const DELIVERED_STEPS = ['delivered', 'deliverypbok'];
+export const RETURNED_STEPS = [
+    'packagereturned',
+    'deliveryreturned',
+    'packagereturnfailed',
+    'deliveryreturnfailed',
+];
+export const CANCELED_STEPS = [
+    'canceled',
+    'cancelled',
+    'deliverycanceled',
+    'deliverycancelled',
+];
+/** A carrier-reported problem that is neither a missed attempt nor a return. */
+export const EXCEPTION_STEPS = ['nondeliverable'];
+export const FAILED_STEPS = [
+    'pickupfailed',
+    'packagewithdrawalfailed',
+    'deliveryfailed',
+];
+export const OUT_FOR_DELIVERY_STEPS = ['outfordelivery', 'deliveryinprogress'];
+export const PICKED_UP_STEPS = ['pickedup', 'packagewithdrawn', 'packagewithdrawalpbok'];
+export const CONFIRMED_STEPS = ['idle', 'confirmed', 'courseaccepted'];
+export function classifyStatus(value) {
+    const key = statusKey(value);
+    if (DELIVERED_STEPS.includes(key)) {
+        return { status: 'delivered', stage: 'delivered', description: 'Livraison effectuée' };
+    }
+    if (RETURNED_STEPS.includes(key)) {
+        return { status: 'exception', stage: 'returned', description: 'Colis retourné' };
+    }
+    if (CANCELED_STEPS.includes(key)) {
+        return { status: 'exception', stage: 'returned', description: 'Livraison annulée' };
+    }
+    if (EXCEPTION_STEPS.includes(key)) {
+        return { status: 'exception', stage: 'exception', description: 'Incident de livraison' };
+    }
+    if (FAILED_STEPS.includes(key)) {
+        return { status: 'exception', stage: 'failed_attempt', description: 'Incident de livraison' };
+    }
+    if (OUT_FOR_DELIVERY_STEPS.includes(key)) {
+        return {
+            status: 'out_for_delivery',
+            stage: 'out_for_delivery',
+            description: 'Livraison en cours',
+        };
+    }
+    if (PICKED_UP_STEPS.includes(key)) {
+        return { status: 'in_transit', stage: 'in_transit', description: 'Colis pris en charge' };
+    }
+    if (CONFIRMED_STEPS.includes(key)) {
+        return { status: 'pending', stage: 'registered', description: 'Livraison confirmée' };
+    }
+    return { status: 'unknown', description: 'Mise à jour Colisweb' };
+}

package/dist/carriers/colisweb/statuses.json

@@ -0,0 +1,25 @@
+{
+  "carrier": "colisweb",
+  "entries": [
+    { "code": "delivered", "stage": "delivered", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Compared with case and separators removed, so delivered and DELIVERED are the same step." },
+    { "code": "delivery_pb_ok", "stage": "delivered", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "package_returned", "stage": "returned", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "delivery_returned", "stage": "returned", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "package_return_failed", "stage": "returned", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "A failed return is still a return leg, not a delivery attempt." },
+    { "code": "delivery_return_failed", "stage": "returned", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "canceled", "stage": "returned", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "Both spellings, canceled and cancelled, are accepted." },
+    { "code": "delivery_canceled", "stage": "returned", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "Both spellings are accepted." },
+    { "code": "non_deliverable", "stage": "exception", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Reclassified to exception 2026-09-12." },
+    { "code": "pickup_failed", "stage": "failed_attempt", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "package_withdrawal_failed", "stage": "failed_attempt", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "delivery_failed", "stage": "failed_attempt", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "out_for_delivery", "stage": "out_for_delivery", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "delivery_in_progress", "stage": "out_for_delivery", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "picked_up", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Also emitted as a milestone event from pickedUpDate." },
+    { "code": "package_withdrawn", "stage": "in_transit", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "package_withdrawal_pb_ok", "stage": "in_transit", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" },
+    { "code": "idle", "stage": "registered", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "The slot is booked and nothing has moved yet." },
+    { "code": "confirmed", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Also emitted as a milestone event from deliveryConfirmationDate." },
+    { "code": "course_accepted", "stage": "registered", "confirmedBy": "official-doc", "firstSeen": "2026-09-12", "note": "" }
+  ]
+}

package/dist/carriers/correios-br/adapter.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+type Solver = (bytes: Uint8Array, signal: AbortSignal) => Promise<string>;
+export declare class CorreiosTracker {
+    private readonly options;
+    private readonly ocr;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        solveCaptcha?: Solver;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+    close(): Promise<void>;
+}
+export declare const adapter: AdapterFactory;
+export {};

package/dist/carriers/correios-br/adapter.js

@@ -0,0 +1,78 @@
+import makeFetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+import { BudgetExceededError, 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 { CorreiosOcr } from './ocr.js';
+import { isCorreiosCaptchaError, normalizeCorreiosNumber, parseCorreios } from './parser.js';
+const ORIGIN = 'https://rastreamento.correios.com.br';
+const HOME = `${ORIGIN}/app/index.php`;
+const IMAGE = `${ORIGIN}/core/securimage/securimage_show.php`;
+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 CorreiosTracker {
+    options;
+    ocr = new CorreiosOcr();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeCorreiosNumber(raw);
+        const budgetMs = context.budgetMs ?? 20_000;
+        return runSteps({ carrier: 'correios-br', budgetMs, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    const deadline = performance.now() + remainingMs;
+                    const check = () => {
+                        signal.throwIfAborted();
+                        const left = deadline - performance.now();
+                        if (left <= 0)
+                            throw new BudgetExceededError('Correios', budgetMs);
+                        return Math.max(1, Math.floor(left));
+                    };
+                    const fetcher = makeFetchCookie(this.options.fetcher ?? fetch, new CookieJar());
+                    const request = async (url, maxBytes) => {
+                        const result = await fetchBounded(url, { signal, headers: { 'User-Agent': USER_AGENT, Referer: HOME } }, {
+                            provider: 'Correios', timeoutMs: check(), maxBytes, fetcher, allowHttpStatuses: [404, 410],
+                        });
+                        check();
+                        if (result.response.status !== 200)
+                            throw new IndeterminateError('Correios', 'Correios tracking endpoint is unavailable');
+                        return result;
+                    };
+                    // A fresh jar binds this parcel's CAPTCHA to this lookup, never another user.
+                    await request(HOME, 100_000);
+                    for (let attempt = 0; attempt < 2; attempt += 1) {
+                        const image = await request(IMAGE, 100_000);
+                        if (!image.response.headers.get('content-type')?.toLowerCase().startsWith('image/png')) {
+                            throw new ChallengeError('Correios', 'Correios returned no text CAPTCHA image');
+                        }
+                        const answer = await (this.options.solveCaptcha ?? this.ocr.solve.bind(this.ocr))(image.bytes, signal);
+                        check();
+                        if (!/^[a-z0-9]{4,6}$/.test(answer)) {
+                            if (attempt === 0)
+                                continue;
+                            throw new ChallengeError('Correios', 'Correios text CAPTCHA could not be read');
+                        }
+                        const url = new URL(`${ORIGIN}/app/resultado.php`);
+                        url.search = new URLSearchParams({ objeto: number, captcha: answer, mqs: 'S' }).toString();
+                        const { bytes } = await request(url, 1_000_000);
+                        let payload;
+                        try {
+                            payload = parseJsonBytes(bytes, 'Correios');
+                        }
+                        catch (cause) {
+                            throw new SchemaError('Correios', 'Correios returned invalid tracking JSON', { cause });
+                        }
+                        if (isCorreiosCaptchaError(payload) && attempt === 0)
+                            continue;
+                        return parseCorreios(payload, number);
+                    }
+                    throw new ChallengeError('Correios', 'Correios rejected the text CAPTCHA');
+                } }]);
+    }
+    close() { return this.ocr.close(); }
+}
+export const adapter = (environment) => {
+    const tracker = new CorreiosTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'correios-br', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/correios-br/carrier.json

@@ -0,0 +1,64 @@
+{
+  "id": "correios-br",
+  "displayName": "Correios Brazil",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "BR"
+    ]
+  },
+  "brand": {
+    "color": "#ffd500"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "correios-br",
+    "steps": [
+      "direct"
+    ],
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location"
+  ],
+  "portal": {
+    "url": "https://rastreamento.correios.com.br/app/index.php?objetos={trackingNumber}",
+    "canaryUrl": "https://rastreamento.correios.com.br/app/index.php",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "estimated_delivery"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location"
+    ],
+    "discarded": [
+      "estimated_delivery"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "correios.com.br"
+      ],
+      "params": [
+        "objetos"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "correios-br-1",
+      "pattern": "^[A-Z]{2}\\d{9}BR$",
+      "confidence": "high",
+      "checksum": "s10"
+    }
+  ]
+}

package/dist/carriers/correios-br/model/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nícolas Pastorello
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.