universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/bring-posten/status.d.ts

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

package/dist/carriers/bring-posten/status.js

@@ -0,0 +1,23 @@
+const groups = [
+    [['PRE_NOTIFIED', 'READY_FROM_SENDER', 'DELIVERY_ORDERED'], { status: 'pending', stage: 'registered' }],
+    [['HANDED_IN', 'COLLECTED', 'COURIER_PICK_UP', 'PICKUP_FROM_MAILBOX'], { status: 'in_transit', stage: 'accepted' }],
+    [['TERMINAL', 'INTERNATIONAL', 'IN_TRANSIT', 'CUSTOMS', 'RETURN', 'DELIVERY_CHANGED'], { status: 'in_transit', stage: 'in_transit' }],
+    [['TRANSPORT_TO_RECIPIENT'], { status: 'out_for_delivery', stage: 'out_for_delivery' }],
+    [['READY_FOR_PICKUP'], { status: 'in_transit', stage: 'ready_for_pickup' }],
+    [['DELIVERED'], { status: 'delivered', stage: 'delivered' }],
+    [['DELIVERED_SENDER'], { status: 'exception', stage: 'returned' }],
+    [['ATTEMPTED_DELIVERY', 'DEVIATION', 'DELIVERY_CANCELLED'], { status: 'exception', stage: 'exception' }],
+];
+const codes = new Map(groups.flatMap(([names, status]) => names.map(name => [name, status])));
+export function bringStatus(code) { return codes.get(code); }
+const labels = new Map([
+    ['PRE_NOTIFIED', 'Shipment information received'], ['READY_FROM_SENDER', 'Ready for collection'],
+    ['DELIVERY_ORDERED', 'Delivery requested'], ['HANDED_IN', 'Handed in'], ['COLLECTED', 'Collected'],
+    ['COURIER_PICK_UP', 'Collected by courier'], ['PICKUP_FROM_MAILBOX', 'Collected from mailbox'],
+    ['TERMINAL', 'At terminal'], ['INTERNATIONAL', 'International transport'], ['IN_TRANSIT', 'In transit'],
+    ['CUSTOMS', 'Customs clearance'], ['RETURN', 'Returning to sender'], ['DELIVERY_CHANGED', 'Delivery rescheduled'],
+    ['TRANSPORT_TO_RECIPIENT', 'Out for delivery'], ['READY_FOR_PICKUP', 'Ready for pickup'],
+    ['DELIVERED', 'Delivered'], ['DELIVERED_SENDER', 'Returned to sender'], ['ATTEMPTED_DELIVERY', 'Delivery attempted'],
+    ['DEVIATION', 'Delivery exception'], ['DELIVERY_CANCELLED', 'Home delivery cancelled'], ['NOTIFICATION_SENT', 'Notification sent'],
+]);
+export function bringWording(code) { return labels.get(code) ?? code.replaceAll('_', ' ').toLowerCase().replace(/^./, letter => letter.toUpperCase()); }

package/dist/carriers/bring-posten/statuses.json

@@ -0,0 +1,33 @@
+{
+  "carrier": "bring-posten",
+  "entries": [
+    {
+      "code": "PRE_NOTIFIED",
+      "wording": "PRE_NOTIFIED",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "HANDED_IN",
+      "wording": "HANDED_IN",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "IN_TRANSIT",
+      "wording": "IN_TRANSIT",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "code": "DELIVERED",
+      "wording": "DELIVERED",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    }
+  ]
+}

package/dist/carriers/brt/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 BrtTracker {
+    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/brt/adapter.js

@@ -0,0 +1,36 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { BudgetExceededError, 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 { normalizeBrtNumber, parseBrt } from './parser.js';
+export class BrtTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    fetch(raw, context = {}) {
+        const number = normalizeBrtNumber(raw);
+        return runSteps({ carrier: 'brt', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    signal.throwIfAborted();
+                    const deadline = performance.now() + remainingMs;
+                    const { response, bytes } = await fetchBounded(`https://vas.brt.it/vas/sped_det_new.htm?brtCode=${number}&lang=en`, { signal }, { provider: 'BRT', timeoutMs: Math.max(1, Math.floor(remainingMs)), maxBytes: 1_000_000,
+                        redirect: 'manual', allowHttpStatuses: [302, 404, 410], fetcher: this.options.fetcher });
+                    if (performance.now() >= deadline)
+                        throw new BudgetExceededError('BRT', context.budgetMs ?? 15_000);
+                    signal.throwIfAborted();
+                    if (response.status !== 200)
+                        throw new IndeterminateError('BRT', 'BRT tracking endpoint is unavailable');
+                    const charset = /charset\s*=\s*["']?([A-Za-z0-9_-]+)/i.exec(response.headers.get('content-type') ?? '')?.[1].toLowerCase();
+                    if (charset && !['utf-8', 'utf8', 'iso-8859-1', 'windows-1252'].includes(charset))
+                        throw new SchemaError('BRT', 'BRT response encoding changed');
+                    return parseBrt(decodeText(bytes, charset?.startsWith('utf') ? 'utf-8' : 'windows-1252'), number);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new BrtTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'brt', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeBrtNumber(number))) };
+};

package/dist/carriers/brt/carrier.json

@@ -0,0 +1,80 @@
+{
+  "id": "brt",
+  "displayName": "BRT",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "IT"
+    ]
+  },
+  "brand": {
+    "color": "#dc0032"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "brt",
+    "steps": [
+      "direct"
+    ],
+    "recognition": {
+      "rank": 42
+    },
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "weight"
+  ],
+  "portal": {
+    "url": "https://vas.brt.it/vas/sped_det_new.htm?brtCode={trackingNumber}&lang=en",
+    "canaryUrl": "https://services.brt.it/en/tracking",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "weight",
+      "merchant_reference",
+      "sender",
+      "recipient",
+      "parcel_count",
+      "volume"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "weight"
+    ],
+    "discarded": [
+      "merchant_reference",
+      "sender",
+      "recipient",
+      "parcel_count",
+      "volume"
+    ],
+    "unavailable": [
+      "offset_timestamps"
+    ]
+  },
+  "links": [
+    {
+      "domains": [
+        "vas.brt.it"
+      ],
+      "path": "^/vas/sped_det_new\\.htm$",
+      "params": [
+        "brtCode"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "brt-1",
+      "pattern": "^\\d{14}$",
+      "confidence": "low"
+    }
+  ]
+}

package/dist/carriers/brt/numbers.json

@@ -0,0 +1,91 @@
+{
+  "carrier": "brt",
+  "records": [
+    {
+      "number": "04503190170072",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6aba3931d3ae76dee1ac45cf",
+        "date": "2026-09-28"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dpd",
+          "dpd-fr",
+          "ciblex",
+          "seur",
+          "brt",
+          "delhivery"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to BRT, which stays one candidate among several."
+    },
+    {
+      "number": "08454077486990",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.altroconsumo.it/reclamare/bacheca-dei-reclami/brt-non-mi-consegna-il-pacco-n/c869ef987b19acc348",
+        "date": "2025-04-24"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dpd",
+          "dpd-fr",
+          "ciblex",
+          "seur",
+          "brt",
+          "delhivery"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to BRT, which stays one candidate among several."
+    },
+    {
+      "number": "25003180070704",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.altroconsumo.it/reclamare/bacheca-dei-reclami/brt-non-mi-consegna-il-pacco-n/c869ef987b19acc348",
+        "date": "2025-04-24"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dpd",
+          "dpd-fr",
+          "ciblex",
+          "seur",
+          "brt",
+          "delhivery"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to BRT, which stays one candidate among several."
+    },
+    {
+      "number": "027280011093919",
+      "role": "quarantined",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.altroconsumo.it/reclamare/bacheca-dei-reclami/firma-falsificata-e-pacco-mai-/f6a66bc9986923ffcf",
+        "date": "2025-07-25"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "fedex",
+          "dpd-fr",
+          "yunda"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to BRT, which no rule claims."
+    }
+  ]
+}

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

@@ -0,0 +1,3 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeBrtNumber(raw: string): string;
+export declare function parseBrt(html: string, raw: string): CarrierResult;

package/dist/carriers/brt/parser.js

@@ -0,0 +1,84 @@
+import { load } from 'cheerio';
+import { IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { calendarDay } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { classifyBrtStatus } from './status.js';
+export function normalizeBrtNumber(raw) {
+    const number = raw.replace(/\s/g, '');
+    if (!/^\d{14}$/.test(number))
+        throw new TypeError('BRT requires a fourteen-digit BRTcode');
+    return number;
+}
+function scanClock(date, clock) {
+    const match = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(date);
+    const day = match && calendarDay(Number(match[3]), Number(match[2]), Number(match[1]));
+    const time = /^(\d{2})\.(\d{2})$/.exec(clock);
+    if (day && time && Number(time[1]) < 24 && Number(time[2]) < 60) {
+        return { local_time: `${day}T${time[1]}:${time[2]}:00` };
+    }
+    const raw = clean(`${date} ${clock}`, 64);
+    return raw ? { provider_time_text: raw } : {};
+}
+export function parseBrt(html, raw) {
+    const number = normalizeBrtNumber(raw);
+    const $ = load(html);
+    const metadata = $('table.table_dati_spedizione');
+    const history = $('table.table_stato_dati');
+    if (!metadata.length && !history.length) {
+        const scope = $('#box_tool_content');
+        const heading = scope.children('h3.separatore');
+        const errors = scope.children('#box_contenuti').clone();
+        errors.find('script, style').remove();
+        if (scope.length === 1 && errors.length === 1 && heading.length === 1 && clean(heading.text(), 80) === 'Errori riscontrati'
+            && clean(errors.text(), 300) === `TIS0868 Parcel Label number ${number} not found`) {
+            throw new NotFoundError('BRT');
+        }
+        throw new IndeterminateError('BRT', 'BRT did not return shipment history');
+    }
+    if (metadata.length !== 1 || history.length > 1)
+        throw new SchemaError('BRT', 'BRT returned ambiguous shipment details');
+    const identityRows = metadata.find('tr').filter((_, node) => clean($(node).children('td').first().text(), 40) === 'BRTcode');
+    const identity = identityRows.children('td');
+    if (identityRows.length !== 1 || identity.length !== 2 || clean(identity.last().text(), 40) !== number) {
+        throw new SchemaError('BRT', 'BRT returned a different or incomplete shipment');
+    }
+    if (!history.length)
+        throw new IndeterminateError('BRT', 'BRT returned no tracking scans');
+    const rows = history.find('tr');
+    if (rows.length > 501)
+        throw new SchemaError('BRT', 'BRT returned too many tracking scans');
+    const header = rows.first().children('td, th').map((_, node) => clean($(node).text(), 40)).get();
+    if (header.join('|') !== 'Data|Ora|Filiale|Evento')
+        throw new SchemaError('BRT', 'BRT tracking columns changed');
+    const events = [];
+    for (const row of rows.slice(1).toArray()) {
+        const cells = $(row).children('td');
+        if (cells.length !== 4)
+            throw new SchemaError('BRT', 'BRT returned an incomplete scan');
+        const date = clean(cells.eq(0).text(), 40);
+        const clock = clean(cells.eq(1).text(), 24);
+        const location = clean(cells.eq(2).text(), 120);
+        const label = clean(cells.eq(3).text(), 160);
+        if (!label || !/^[\p{L}][\p{L}\p{N}\s().,'/-]{1,159}$/u.test(label))
+            throw new SchemaError('BRT', 'BRT returned an invalid scan label');
+        const mapped = classifyBrtStatus(label);
+        events.push({ description: mapped?.status === 'delivered' ? 'Delivered' : label, provider_status: label,
+            ...(mapped ? { stage: mapped.stage } : {}), ...(location ? { location } : {}), ...scanClock(date, clock) });
+    }
+    if (!events.length)
+        throw new IndeterminateError('BRT', 'BRT returned empty tracking history');
+    // BRT includes cross-border depots without identifying each scan's zone.
+    // Source order also carries undated scans, so local clocks are never sorted.
+    const latest = events[0];
+    const mapped = classifyBrtStatus(String(latest.provider_status));
+    const goodsRows = metadata.find('tr').filter((_, node) => clean($(node).children('td').first().text(), 40) === 'Natura merce');
+    const weightText = goodsRows.length === 1 ? clean(goodsRows.children('td').last().text(), 300) : '';
+    const weightLabels = weightText.match(/\bPeso \(kg\):/g) ?? [];
+    const weightMatch = /\bPeso \(kg\):\s*(\d+(?:[,.]\d{1,4})?)(?=\s+Volume\b|$)/.exec(weightText);
+    const weight = weightLabels.length === 1 && weightMatch ? Number(weightMatch[1].replace(',', '.')) : NaN;
+    return { status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        last_status_text: latest.description, last_update: null,
+        ...(latest.local_time ? { last_update_local: latest.local_time } : {}),
+        ...(Number.isFinite(weight) && weight > 0 && weight <= 100_000 ? { weight_kg: weight } : {}),
+        events: events.slice(0, 100) };
+}

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

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

package/dist/carriers/brt/status.js

@@ -0,0 +1,14 @@
+const labels = {
+    'SHIPPING INFO SENT TO BRT': { status: 'pending', stage: 'registered' },
+    COLLECTED: { status: 'in_transit', stage: 'accepted' },
+    DEPARTED: { status: 'in_transit', stage: 'in_transit' },
+    'ARRIVED AT DEPOT': { status: 'in_transit', stage: 'in_transit' },
+    'FOR DELIVERY': { status: 'out_for_delivery', stage: 'out_for_delivery' },
+    'ARRIVED AT BRT LOCKER': { status: 'in_transit', stage: 'ready_for_pickup' },
+    'COLLECTED AT BRT LOCKER': { status: 'delivered', stage: 'delivered' },
+    DELIVERED: { status: 'delivered', stage: 'delivered' },
+};
+export function classifyBrtStatus(label) {
+    const key = label.toUpperCase().trim();
+    return Object.hasOwn(labels, key) ? labels[key] : undefined;
+}

package/dist/carriers/brt/statuses.json

@@ -0,0 +1,53 @@
+{
+  "carrier": "brt",
+  "entries": [
+    {
+      "wording": "SHIPPING INFO SENT TO BRT",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "COLLECTED",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "DEPARTED",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "ARRIVED AT DEPOT",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "FOR DELIVERY",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "ARRIVED AT BRT LOCKER",
+      "language": "en",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "COLLECTED AT BRT LOCKER",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    },
+    {
+      "wording": "DELIVERED",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live"
+    }
+  ]
+}

package/dist/carriers/c-chez-vous/adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * C Chez Vous: the public order-tracking page at cchezvous.fr/suivi-colis.
+ *
+ * One bounded GET per lookup ('direct' step). The page embeds its whole order
+ * record as JSON in a `<tracking :tracking-results="…">` attribute: the shop,
+ * the recipient's name, address, phone and e-mail, the ordered articles and the
+ * booked time window sit next to the per-parcel step. `parse()` reads the step
+ * and the delivery date and nothing else.
+ *
+ * The order reference alone opens that page, so it is part of the tracking
+ * credential: never log it, quote it in an issue, or put a real one in a
+ * fixture.
+ */
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export { STEP_DETAILS, stepDetails } from './status.js';
+export declare function normalizeCChezVousCredential(raw: string): string;
+export declare function cChezVousTrackingUrl(rawCredential: string): string;
+export declare function parseCChezVousTrackingHtml(html: string, rawCredential: string): CarrierResult;
+export interface CChezVousTrackerOptions {
+    timeoutMs?: number;
+    /** Test seam; production uses the global fetch. */
+    fetcher?: typeof fetch;
+}
+export declare class CChezVousTracker {
+    #private;
+    readonly timeoutMs: number;
+    constructor(options?: CChezVousTrackerOptions);
+    fetch(rawCredential: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/c-chez-vous/adapter.js

@@ -0,0 +1,181 @@
+/**
+ * C Chez Vous: the public order-tracking page at cchezvous.fr/suivi-colis.
+ *
+ * One bounded GET per lookup ('direct' step). The page embeds its whole order
+ * record as JSON in a `<tracking :tracking-results="…">` attribute: the shop,
+ * the recipient's name, address, phone and e-mail, the ordered articles and the
+ * booked time window sit next to the per-parcel step. `parse()` reads the step
+ * and the delivery date and nothing else.
+ *
+ * The order reference alone opens that page, so it is part of the tracking
+ * credential: never log it, quote it in an issue, or put a real one in a
+ * fixture.
+ */
+import { load } from 'cheerio';
+import { NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { UpstreamHttpError, clean, decodeText, fetchBounded } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { UNKNOWN_STEP, UNKNOWN_STEP_DESCRIPTION, parcelStep, stepDetails } from './status.js';
+export { STEP_DETAILS, stepDetails } from './status.js';
+const PROVIDER = 'C Chez Vous';
+const TRACKING_BASE = 'https://www.cchezvous.fr/suivi-colis';
+const TIMEZONE = 'Europe/Paris';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 1_000_000;
+const FRENCH_POSTCODE = /^(?:0[1-9]|[1-8]\d|9[0-5]|97|98)\d{3}$/;
+const NOT_FOUND_PATTERN = /commande est introuvable|commande introuvable/i;
+/**
+ * The embedded record carries ISO timestamps for the delivery appointment. Only
+ * the calendar day is kept, so no `core/time` policy applies: the day is read
+ * off the string, and a string `Date.parse` refuses is dropped.
+ */
+function normalizedIsoDate(value) {
+    if (typeof value !== 'string')
+        return null;
+    const candidate = value.trim();
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(candidate);
+    if (!match || Number.isNaN(Date.parse(candidate)))
+        return null;
+    return `${match[1]}-${match[2]}-${match[3]}`;
+}
+function normalizeResponseCredential(value) {
+    if (typeof value !== 'string') {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned an invalid shipment number');
+    }
+    try {
+        return normalizeCChezVousCredential(value);
+    }
+    catch (error) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned an invalid shipment number', { cause: error });
+    }
+}
+export function normalizeCChezVousCredential(raw) {
+    const value = raw.trim().toLocaleUpperCase('en-US').replace(/\s/g, '');
+    const composite = /^([A-Z0-9]{11})--(\d{5})$/.exec(value);
+    if (composite) {
+        if (!FRENCH_POSTCODE.test(composite[2])) {
+            throw new TypeError('C Chez Vous tracking contains an invalid French postcode');
+        }
+        return `${composite[1]}--${composite[2]}`;
+    }
+    // Shared package normalization removes punctuation. The only documented compact
+    // composite form has an 11-character order followed by its 5-digit postcode.
+    const compactComposite = /^([A-Z0-9]{11})(\d{5})$/.exec(value);
+    if (compactComposite) {
+        if (!FRENCH_POSTCODE.test(compactComposite[2])) {
+            throw new TypeError('C Chez Vous tracking contains an invalid French postcode');
+        }
+        return `${compactComposite[1]}--${compactComposite[2]}`;
+    }
+    if (!/^(?=.*\d)[A-Z0-9]{8,15}$/.test(value)) {
+        throw new TypeError('C Chez Vous tracking requires an 8- to 15-character order number, or an 11-character order followed by -- and a French postcode');
+    }
+    return value;
+}
+export function cChezVousTrackingUrl(rawCredential) {
+    const credential = normalizeCChezVousCredential(rawCredential);
+    return `${TRACKING_BASE}/${encodeURIComponent(credential)}`;
+}
+export function parseCChezVousTrackingHtml(html, rawCredential) {
+    const credential = normalizeCChezVousCredential(rawCredential);
+    if (!html.trim())
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned an empty tracking response');
+    if (NOT_FOUND_PATTERN.test(html))
+        throw new NotFoundError(PROVIDER);
+    const $ = load(html);
+    const tracking = $('tracking').first();
+    const encodedResult = tracking.attr(':tracking-results')
+        ?? tracking.attr('v-bind:tracking-results');
+    if (!encodedResult)
+        throw new SchemaError(PROVIDER, 'C Chez Vous did not return tracking details');
+    let payload;
+    try {
+        payload = JSON.parse(encodedResult);
+    }
+    catch (error) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned an invalid tracking response', { cause: error });
+    }
+    if (!isRecord(payload)) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned an invalid tracking response');
+    }
+    const responseCredential = normalizeResponseCredential(payload.package_number);
+    if (responseCredential !== credential) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned a different shipment');
+    }
+    const displayedCredential = clean($('.title--tertiary').first().text(), 64);
+    if (displayedCredential
+        && normalizeResponseCredential(displayedCredential) !== credential) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned a different shipment');
+    }
+    const parcels = Array.isArray(payload.parcels) ? payload.parcels.filter(isRecord) : [];
+    if (parcels.length === 0) {
+        throw new SchemaError(PROVIDER, 'C Chez Vous returned incomplete tracking details');
+    }
+    const steps = parcels.map((parcel) => parcelStep(parcel.parcelStep));
+    // A multi-parcel order is complete only when its least-advanced parcel is complete,
+    // and a parcel on a step we do not know makes the whole order unknown.
+    const currentStep = steps.includes(UNKNOWN_STEP) ? UNKNOWN_STEP : Math.min(...steps);
+    const current = stepDetails(currentStep);
+    const deliveryDates = parcels
+        .map((parcel) => normalizedIsoDate(parcel.date))
+        .filter((date) => date !== null)
+        .sort();
+    const expectedDelivery = deliveryDates.at(-1) ?? null;
+    return {
+        status: current?.status ?? 'unknown',
+        ...(current ? { current_stage: current.stage } : {}),
+        last_status_text: current?.description ?? UNKNOWN_STEP_DESCRIPTION,
+        last_update: null,
+        expected_delivery: current?.status === 'delivered' ? null : expectedDelivery,
+        timezone: TIMEZONE,
+        events: [{
+                description: current?.description ?? UNKNOWN_STEP_DESCRIPTION,
+                // An unknown step carries no stage: the sync classifies and records it.
+                ...(current ? { stage: current.stage } : {}),
+            }],
+    };
+}
+export class CChezVousTracker {
+    timeoutMs;
+    #fetcher;
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new TypeError('C Chez Vous timeout must be positive');
+        }
+        this.#fetcher = options.fetcher;
+    }
+    async fetch(rawCredential) {
+        const credential = normalizeCChezVousCredential(rawCredential);
+        const { response, bytes } = await fetchBounded(cChezVousTrackingUrl(credential), {
+            headers: {
+                Accept: 'text/html,application/xhtml+xml',
+                'Accept-Language': 'fr-FR,fr;q=0.9',
+                'User-Agent': 'Mozilla/5.0 (compatible; DeliveryTracker/1.0)',
+            },
+        }, {
+            provider: 'C Chez Vous tracking',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_RESPONSE_BYTES,
+            redirect: 'manual',
+            allowHttpError: true,
+            fetcher: this.#fetcher,
+        });
+        // An unknown order is redirected back to the tracking form instead of a 404.
+        if (response.status === 404 || (response.status >= 300 && response.status < 400)) {
+            throw new NotFoundError(PROVIDER);
+        }
+        if (!response.ok)
+            throw new UpstreamHttpError('C Chez Vous tracking', response.status);
+        return parseCChezVousTrackingHtml(decodeText(bytes), credential);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new CChezVousTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'c-chez-vous',
+        steps: ['direct'],
+        // The postcode, when the order needs one, is already part of the stored number.
+        track: (input) => tracker.fetch(input.number),
+    };
+};