universal-parcel-scraper 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,72 @@
+{
+  "carrier": "correios-br",
+  "records": [
+    {
+      "number": "AD803652820BR",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://github.com/universidadedeterapias/meDIZ/pull/86",
+        "date": "2026-08-20"
+      },
+      "expect": {
+        "carrier": "correios-br",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    },
+    {
+      "number": "ES446391025BR",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/guilhermechapiewski/correios-api-py"
+      },
+      "expect": {
+        "carrier": "correios-br",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LB571181225HK",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/FelipeMorandini/rastreador_correios"
+      },
+      "expect": {
+        "carrier": "hongkong-post",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Correios Brazil; detection selects Hongkong Post."
+    },
+    {
+      "number": "NN376766183BR",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6ab708ba54e925ea877fb1b1",
+        "date": "2026-09-26"
+      },
+      "expect": {
+        "carrier": "correios-br",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. AliExpress item still on its Cainiao leg when reported."
+    },
+    {
+      "number": "RA222491899CN",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/leandrotoledo/python-correios"
+      },
+      "expect": {
+        "carrier": "china-post",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Correios Brazil; detection selects China Post."
+    }
+  ]
+}

package/dist/carriers/correios-br/ocr-worker.mjs

@@ -0,0 +1,53 @@
+import { parentPort } from 'node:worker_threads';
+import { readFile } from 'node:fs/promises';
+import * as ort from 'onnxruntime-web';
+import sharp from 'sharp';
+
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+const BLANK = ALPHABET.length;
+ort.env.wasm.numThreads = 1;
+let session;
+
+export function decodeCorreiosLogits(data, dims) {
+  if (dims.length !== 3 || dims[0] !== 53 || dims[1] !== 1 || dims[2] !== 37 || data.length !== 53 * 37) {
+    throw new Error('Correios OCR returned an invalid tensor');
+  }
+  let previous = -1;
+  let answer = '';
+  for (let step = 0; step < 53; step += 1) {
+    let best = 0;
+    for (let column = 0; column < 37; column += 1) {
+      const value = data[step * 37 + column];
+      if (!Number.isFinite(value)) throw new Error('Correios OCR returned an invalid score');
+      if (value > data[step * 37 + best]) best = column;
+    }
+    if (best !== previous && best !== BLANK) answer += ALPHABET[best];
+    previous = best;
+  }
+  return answer;
+}
+
+async function solve(bytes) {
+  if (!(bytes instanceof Uint8Array) || !bytes.byteLength || bytes.byteLength > 100_000) throw new Error('unsupported-image');
+  let pixels;
+  try {
+    const image = sharp(bytes, { limitInputPixels: 215 * 80, pages: 1, failOn: 'warning' });
+    const metadata = await image.metadata();
+    if (metadata.format !== 'png' || metadata.width !== 215 || metadata.height !== 80 || (metadata.pages ?? 1) !== 1) throw new Error('unsupported-image');
+    pixels = await image.flatten({ background: '#ffffff' }).greyscale().resize(215, 80, { kernel: 'linear' }).raw().toBuffer();
+    if (pixels.length !== 215 * 80) throw new Error('unsupported-image');
+  } catch { throw new Error('unsupported-image'); }
+  const input = Float32Array.from(pixels, (pixel) => pixel / 127.5 - 1);
+  if (!session) {
+    const model = await readFile(new URL('./model/captcha.onnx', import.meta.url));
+    session = await ort.InferenceSession.create(new Uint8Array(model), { executionProviders: ['wasm'], graphOptimizationLevel: 'all' });
+  }
+  const output = (await session.run({ image: new ort.Tensor('float32', input, [1, 1, 80, 215]) })).logits;
+  if (!output || output.type !== 'float32') throw new Error('Correios OCR returned an invalid output');
+  return decodeCorreiosLogits(output.data, output.dims);
+}
+
+parentPort?.on('message', async ({ id, bytes }) => {
+  try { parentPort.postMessage({ id, answer: await solve(bytes) }); }
+  catch (error) { parentPort.postMessage({ id, error: error?.message === 'unsupported-image' ? 'unsupported-image' : 'inference-failed' }); }
+});

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

@@ -0,0 +1,10 @@
+/** One lazy CPU worker reuses its model; queued work shares the lookup deadline. */
+export declare class CorreiosOcr {
+    private worker;
+    private tail;
+    private nextId;
+    private queued;
+    private idleTimer;
+    solve(bytes: Uint8Array, signal: AbortSignal): Promise<string>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,83 @@
+import { Worker } from 'node:worker_threads';
+import { ChallengeError, TransportError } from '../../core/errors/index.js';
+function withAbort(operation, signal, abort) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const cancelled = () => { abort?.(); reject(signal.reason); };
+        signal.addEventListener('abort', cancelled, { once: true });
+        operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', cancelled));
+    });
+}
+/** One lazy CPU worker reuses its model; queued work shares the lookup deadline. */
+export class CorreiosOcr {
+    worker = null;
+    tail = Promise.resolve();
+    nextId = 0;
+    queued = 0;
+    idleTimer = null;
+    async solve(bytes, signal) {
+        signal.throwIfAborted();
+        if (this.queued >= 8)
+            throw new TransportError('Correios', 'Correios OCR worker is busy');
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+        this.queued += 1;
+        let release;
+        const previous = this.tail;
+        this.tail = new Promise((resolve) => { release = resolve; });
+        try {
+            await withAbort(previous, signal);
+            signal.throwIfAborted();
+            const worker = this.worker ??= new Worker(new URL('./ocr-worker.mjs', import.meta.url));
+            worker.ref();
+            const id = ++this.nextId;
+            const operation = new Promise((resolve, reject) => {
+                const cleanup = () => { worker.off('message', message); worker.off('error', error); worker.off('exit', exited); };
+                const message = (reply) => {
+                    if (reply.id !== id)
+                        return;
+                    cleanup();
+                    if (reply.error === 'unsupported-image')
+                        reject(new ChallengeError('Correios', 'Correios returned an unsupported text CAPTCHA'));
+                    else if (reply.error || typeof reply.answer !== 'string')
+                        reject(new TransportError('Correios', 'Correios OCR could not run'));
+                    else
+                        resolve(reply.answer);
+                };
+                const error = () => { cleanup(); if (this.worker === worker)
+                    this.worker = null; reject(new TransportError('Correios', 'Correios OCR worker failed')); };
+                const exited = () => { cleanup(); if (this.worker === worker)
+                    this.worker = null; reject(new TransportError('Correios', 'Correios OCR worker stopped')); };
+                worker.on('message', message);
+                worker.once('error', error);
+                worker.once('exit', exited);
+                worker.postMessage({ id, bytes });
+            });
+            try {
+                return await withAbort(operation, signal, () => { this.worker = null; void worker.terminate(); });
+            }
+            finally {
+                worker.unref();
+            }
+        }
+        finally {
+            this.queued -= 1;
+            if (this.queued === 0 && this.worker) {
+                this.idleTimer = setTimeout(() => { void this.close(); }, 30_000);
+                this.idleTimer.unref();
+            }
+            // If cancelled while queued, preserve the preceding operation's lock.
+            void previous.finally(release);
+        }
+    }
+    async close() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+        const worker = this.worker;
+        this.worker = null;
+        if (worker)
+            await worker.terminate();
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeCorreiosNumber(raw: string): string;
+export declare function isCorreiosCaptchaError(payload: unknown): boolean;
+export declare function parseCorreios(payload: unknown, number: string): CarrierResult;

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

@@ -0,0 +1,79 @@
+import { DateTime, IANAZone } from 'luxon';
+import { isValidS10TrackingNumber } from '../../core/detection/s10.js';
+import { ChallengeError, IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyCorreiosStatus } from './status.js';
+export function normalizeCorreiosNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^[A-Z]{2}\d{9}[A-Z]{2}$/.test(number) || !isValidS10TrackingNumber(number)) {
+        throw new TypeError('Correios requires a valid postal S10 tracking number');
+    }
+    return number;
+}
+export function isCorreiosCaptchaError(payload) {
+    return isRecord(payload) && (payload.erro === true || payload.erro === 'true')
+        && clean(payload.mensagem, 100).toLowerCase() === 'captcha inválido';
+}
+function scanClock(value) {
+    const raw = clean(isRecord(value) ? value.date : value, 64);
+    const digits = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})(?:\.\d{1,6})?$/.exec(raw)?.[1];
+    const wall = digits ? DateTime.fromFormat(digits, 'yyyy-MM-dd HH:mm:ss', { zone: 'UTC' }) : null;
+    if (!wall?.isValid)
+        return raw ? { provider_time_text: raw } : {};
+    const local = wall.toISO({ includeOffset: false, suppressMilliseconds: true });
+    const zone = isRecord(value) && value.timezone_type === 3 ? clean(value.timezone, 64) : '';
+    if (!zone || !IANAZone.isValidZone(zone))
+        return { local_time: local };
+    // Use the explicit per-row zone only when its clock exists uniquely. Do not
+    // silently shift a nonexistent DST clock or choose between repeated clocks.
+    const zoned = DateTime.fromFormat(digits, 'yyyy-MM-dd HH:mm:ss', { zone });
+    if (!zoned.isValid || zoned.toFormat('yyyy-MM-dd HH:mm:ss') !== digits || zoned.getPossibleOffsets().length !== 1) {
+        return { local_time: local };
+    }
+    return { time: zoned.toISO({ suppressMilliseconds: true }) };
+}
+export function parseCorreios(payload, number) {
+    const requested = normalizeCorreiosNumber(number);
+    if (!isRecord(payload))
+        throw new SchemaError('Correios');
+    if (isCorreiosCaptchaError(payload))
+        throw new ChallengeError('Correios', 'Correios rejected the text CAPTCHA');
+    // Period errors and other unbound error replies prove neither absence nor identity.
+    if (payload.erro === true || payload.erro === 'true')
+        throw new IndeterminateError('Correios', 'Correios returned an inconclusive tracking response');
+    if (payload.codObjeto !== requested)
+        throw new SchemaError('Correios', 'Correios returned a different tracking object');
+    if (!Array.isArray(payload.eventos) || payload.eventos.length > 500)
+        throw new SchemaError('Correios');
+    const events = [];
+    const seen = new Set();
+    for (const row of payload.eventos) {
+        if (!isRecord(row))
+            throw new SchemaError('Correios', 'Correios returned an incomplete scan');
+        const code = clean(row.codigo, 8);
+        const subtype = clean(row.tipo, 8);
+        const description = clean(row.descricao, 500);
+        if (!/^[A-Z]{2,4}$/.test(code) || !/^\d{2}$/.test(subtype) || !description)
+            throw new SchemaError('Correios', 'Correios returned an incomplete scan');
+        const providerCode = `${code}/${subtype}`;
+        const clock = scanClock(row.dtHrCriado);
+        const address = isRecord(row.unidade) && isRecord(row.unidade.endereco) ? row.unidade.endereco : null;
+        const location = address ? [clean(address.cidade, 100), clean(address.uf, 8)].filter(Boolean).join(', ') : '';
+        const key = `${clock.time ?? clock.local_time ?? clock.provider_time_text ?? ''}\u0000${providerCode}\u0000${description}\u0000${location}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const mapped = classifyCorreiosStatus(providerCode);
+        events.push({ description, provider_code: providerCode, ...clock, ...(location ? { location } : {}), ...(mapped ? { stage: mapped.stage } : {}) });
+    }
+    if (!events.length)
+        throw new IndeterminateError('Correios', 'Correios returned no tracking scans');
+    // The single-object response is newest first. Keep unresolved clocks there.
+    const latest = events[0];
+    const mapped = classifyCorreiosStatus(latest.provider_code ?? '');
+    return { status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        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: events.slice(0, 100) };
+}

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

@@ -0,0 +1,2 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function classifyCorreiosStatus(code: string): ClassifiedStatus | undefined;

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

@@ -0,0 +1,17 @@
+// Subtypes distinguish delivery from address problems and cancelled dispatches.
+const codes = {
+    'BDE/01': { status: 'delivered', stage: 'delivered' },
+    'BDE/34': { status: 'exception', stage: 'exception' },
+    'BDE/47': { status: 'exception', stage: 'exception' },
+    'OEC/01': { status: 'out_for_delivery', stage: 'out_for_delivery' },
+    'DO/01': { status: 'in_transit', stage: 'in_transit' },
+    'RO/01': { status: 'in_transit', stage: 'in_transit' },
+    'PAR/10': { status: 'in_transit', stage: 'in_transit' },
+    'PAR/16': { status: 'in_transit', stage: 'accepted' },
+    'PO/01': { status: 'in_transit', stage: 'accepted' },
+    'PAR/07': { status: 'in_transit', stage: 'in_transit' },
+    'PAR/21': { status: 'in_transit', stage: 'customs' },
+};
+export function classifyCorreiosStatus(code) {
+    return Object.hasOwn(codes, code) ? codes[code] : undefined;
+}

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

@@ -0,0 +1,16 @@
+{
+  "carrier": "correios-br",
+  "entries": [
+    { "code": "BDE/01", "wording": "Objeto entregue ao destinatário", "language": "pt", "stage": "delivered", "confirmedBy": "live" },
+    { "code": "BDE/34", "wording": "Inconsistências no endereçamento do objeto", "language": "pt", "stage": "exception", "confirmedBy": "live" },
+    { "code": "BDE/47", "wording": "Saída para entrega cancelada", "language": "pt", "stage": "exception", "confirmedBy": "live" },
+    { "code": "OEC/01", "wording": "Objeto saiu para entrega ao destinatário", "language": "pt", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "DO/01", "wording": "Objeto em transferência - por favor aguarde", "language": "pt", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "RO/01", "wording": "Objeto em transferência - por favor aguarde", "language": "pt", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "PAR/10", "wording": "Saída do Centro Internacional", "language": "pt", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "PAR/16", "wording": "Objeto recebido pelos Correios do Brasil", "language": "pt", "stage": "accepted", "confirmedBy": "live" },
+    { "code": "PO/01", "wording": "Objeto postado", "language": "pt", "stage": "accepted", "confirmedBy": "live" },
+    { "code": "PAR/07", "wording": "Análise concluída - importação autorizada", "language": "pt", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "PAR/21", "wording": "Informações enviadas para análise da autoridade aduaneira/órgãos anuentes", "language": "pt", "stage": "customs", "confirmedBy": "live" }
+  ]
+}

package/dist/carriers/correos-chile/adapter.d.ts

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

package/dist/carriers/correos-chile/adapter.js

@@ -0,0 +1,85 @@
+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 { decodeText, fetchBounded } from '../../core/transport/index.js';
+import { normalizeCorreosChileNumber, parseCorreosChileBootstrap, parseCorreosChileTracking } from './parser.js';
+const PAGE = 'https://www.correos.cl/seguimiento-en-linea';
+const ORIGIN = 'https://www.correos.cl';
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/154.0.0.0 Safari/537.36';
+const BOOTSTRAP_MAX_BYTES = 500_000;
+// The anonymous resource includes the full public branch list alongside the
+// requested shipment, even though only the shipment detail is projected.
+const TRACKING_MAX_BYTES = 6_000_000;
+function anonymousSession(response) {
+    const cookies = new Map();
+    for (const header of response.headers.getSetCookie()) {
+        const part = header.split(';', 1)[0] ?? '';
+        const match = /^(JSESSIONID|SERVER_ID)=([A-Za-z0-9._~!$%&'*+\-^`|:=@]{1,512})$/.exec(part);
+        if (match)
+            cookies.set(match[1], part);
+    }
+    if (!cookies.has('JSESSIONID') || !cookies.has('SERVER_ID')) {
+        throw new IndeterminateError('Correos de Chile', 'Anonymous tracking session is missing');
+    }
+    return `${cookies.get('JSESSIONID')}; ${cookies.get('SERVER_ID')}`;
+}
+export class CorreosChileTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizeCorreosChileNumber(raw);
+        const budgetMs = context.budgetMs ?? 15_000;
+        return runSteps({ carrier: 'correos-chile', budgetMs, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    const deadline = performance.now() + remainingMs;
+                    const read = async (url, init, maxBytes) => {
+                        signal.throwIfAborted();
+                        const left = deadline - performance.now();
+                        if (left <= 0)
+                            throw new BudgetExceededError('Correos de Chile', budgetMs);
+                        const result = await fetchBounded(url, { ...init, signal }, {
+                            provider: 'Correos de Chile', timeoutMs: Math.max(1, Math.floor(left)), maxBytes,
+                            redirect: 'manual', allowHttpStatuses: [302, 404, 410], fetcher: this.options.fetcher,
+                        });
+                        if (performance.now() >= deadline)
+                            throw new BudgetExceededError('Correos de Chile', budgetMs);
+                        signal.throwIfAborted();
+                        if (result.response.status !== 200) {
+                            throw new IndeterminateError('Correos de Chile', 'Anonymous tracking resource is unavailable');
+                        }
+                        return result;
+                    };
+                    const bootstrap = await read(PAGE, { headers: {
+                            'User-Agent': USER_AGENT,
+                            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                            'Accept-Language': 'es-CL,es;q=0.9,en;q=0.8',
+                        } }, BOOTSTRAP_MAX_BYTES);
+                    const html = decodeText(bootstrap.bytes);
+                    const session = parseCorreosChileBootstrap(html);
+                    const cookie = anonymousSession(bootstrap.response);
+                    const body = new URLSearchParams({ [session.numberField]: number, p_auth: session.csrf });
+                    const tracking = await read(session.url, { method: 'POST', body, headers: {
+                            'User-Agent': USER_AGENT, 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                            'X-Requested-With': 'XMLHttpRequest', Origin: ORIGIN, Referer: PAGE, Cookie: cookie,
+                        } }, TRACKING_MAX_BYTES);
+                    const text = decodeText(tracking.bytes);
+                    if (/Radware (?:Captcha )?Page|Please solve this CAPTCHA/i.test(text)) {
+                        throw new ChallengeError('Correos de Chile', 'Tracking resource returned a browser challenge');
+                    }
+                    let payload;
+                    try {
+                        payload = JSON.parse(text);
+                    }
+                    catch {
+                        throw new SchemaError('Correos de Chile', 'Tracking resource returned invalid JSON');
+                    }
+                    return parseCorreosChileTracking(payload, number);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new CorreosChileTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'correos-chile', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/correos-chile/carrier.json

@@ -0,0 +1,62 @@
+{
+  "id": "correos-chile",
+  "displayName": "Correos de Chile",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "CL"
+    ]
+  },
+  "brand": {
+    "color": "#d9232d"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "correos-chile",
+    "steps": [
+      "direct"
+    ],
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "provider_code"
+  ],
+  "portal": {
+    "url": "https://www.correos.cl/seguimiento-en-linea",
+    "canaryUrl": "https://t.17track.net/",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "recipient_name"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "provider_code"
+    ],
+    "discarded": [
+      "recipient_name"
+    ],
+    "unavailable": []
+  },
+  "links": [],
+  "detection": [
+    {
+      "id": "correos-chile-1",
+      "pattern": "^\\d{13}$",
+      "confidence": "low"
+    },
+    {
+      "id": "correos-chile-2",
+      "pattern": "^[A-Z]{2}\\d{9}CL$",
+      "confidence": "high",
+      "checksum": "s10"
+    }
+  ]
+}

package/dist/carriers/correos-chile/numbers.json

@@ -0,0 +1,38 @@
+{
+  "carrier": "correos-chile",
+  "records": [
+    {
+      "number": "3072708247886",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/josemontesp/correos"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "la-poste",
+          "correos-chile",
+          "delhivery",
+          "yunda"
+        ]
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Correos de Chile, which stays one candidate among several."
+    },
+    {
+      "number": "RR400244295CL",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.chinapostaltracking.com/qa/i-sent-a-book-from-chile-to-a-printing-company-in-china-157068/",
+        "date": "2026-02-24"
+      },
+      "expect": {
+        "carrier": "correos-chile",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. Sent from Chile to China."
+    }
+  ]
+}

package/dist/carriers/correos-chile/parser.d.ts

@@ -0,0 +1,9 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeCorreosChileNumber(raw: string): string;
+export interface ChileBootstrap {
+    url: string;
+    numberField: string;
+    csrf: string;
+}
+export declare function parseCorreosChileBootstrap(html: string): ChileBootstrap;
+export declare function parseCorreosChileTracking(payload: unknown, raw: string): CarrierResult;