universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/ctt-express/parser.js

@@ -0,0 +1,107 @@
+import { DateTime } from 'luxon';
+import { IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { calendarDay, explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyCttExpressStatus } from './status.js';
+export function normalizeCttExpressNumber(raw) {
+    const number = raw.replace(/[\s.-]/g, '');
+    if (!/^00\d{20}$/.test(number))
+        throw new TypeError('CTT Express requires a Spanish shipment tracking number');
+    return number;
+}
+function scanClock(value) {
+    const raw = clean(value, 64);
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):?[0-5]\d)$/.test(raw)) {
+        const instant = explicitOffsetTime(raw);
+        if (instant)
+            return { time: instant.iso };
+    }
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?$/.test(raw)) {
+        const wall = DateTime.fromISO(raw, { zone: 'UTC' });
+        if (wall.isValid)
+            return { local_time: wall.toISO({ includeOffset: false, suppressMilliseconds: true }) };
+    }
+    return raw ? { provider_time_text: raw } : {};
+}
+export function parseCttExpress(payload, number) {
+    const requested = normalizeCttExpressNumber(number);
+    if (!isRecord(payload))
+        throw new SchemaError('CTT Express');
+    // An upstream Invalid token reply can precede successful anonymous retrieval.
+    // No error signature has established a reliable parcel-negative response.
+    if (payload.error != null)
+        throw new IndeterminateError('CTT Express', 'CTT Express returned an inconclusive tracking response');
+    const data = payload.data;
+    if (!isRecord(data) || data.shipping_code !== requested || !isRecord(data.shipping_history)) {
+        throw new SchemaError('CTT Express', 'CTT Express returned a different or incomplete shipment');
+    }
+    const history = data.shipping_history;
+    if (!Array.isArray(history.events) || history.events.length > 500)
+        throw new SchemaError('CTT Express');
+    if (!history.events.length)
+        throw new IndeterminateError('CTT Express', 'CTT Express returned no tracking scans');
+    // The public response contains one package's history. Shipment completion
+    // cannot be inferred from one delivered package of a multi-piece shipment.
+    if (data.item_count !== 1)
+        throw new IndeterminateError('CTT Express', 'CTT Express did not return a single-piece shipment');
+    // Official label specification: 22 shipment digits + 3 parcel-counter digits.
+    if (history.item_code !== `${requested}001`)
+        throw new SchemaError('CTT Express', 'CTT Express returned a different package');
+    const events = [];
+    // Newest provider positions win equal-clock ties. Preserve duplicates until
+    // their chronological leg is known so an earlier return start is not lost.
+    for (const row of [...history.events].reverse()) {
+        if (!isRecord(row) || row.type !== 'STATUS' || !['ITEM_STATUS_V2', 'ITEM_STATUS_CHANGE_V1'].includes(clean(row.source, 64))) {
+            throw new SchemaError('CTT Express', 'CTT Express returned an unsupported scan source');
+        }
+        const code = clean(row.code, 16);
+        const description = clean(row.description, 500);
+        if (!/^\d{4}$/.test(code) || !description)
+            throw new SchemaError('CTT Express', 'CTT Express returned an incomplete scan');
+        const clock = scanClock(row.event_date);
+        const mapped = classifyCttExpressStatus(code);
+        events.push({ provider_code: code, description, ...clock, ...(mapped ? { stage: mapped.stage } : {}) });
+    }
+    // An unresolved newest scan must not yield to an older instant.
+    if (events.every((event) => event.time))
+        events.sort((a, b) => Date.parse(b.time) - Date.parse(a.time));
+    // 2500 explicitly starts delivery back to the sender. Apply that evidence
+    // chronologically, using the provider's order whenever a clock is unresolved.
+    // Movement on that leg remains movement; only completed delivery is returned.
+    let returning = false;
+    for (const event of [...events].reverse()) {
+        if (event.provider_code === '2500')
+            returning = true;
+        if (!returning)
+            continue;
+        event.provider_leg = 'return';
+        if (event.stage === 'delivered')
+            event.stage = 'returned';
+    }
+    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;
+    });
+    const latest = unique[0];
+    const mapped = classifyCttExpressStatus(latest.provider_code ?? '');
+    const returned = latest.stage === 'returned';
+    const eta = clean(data.committed_delivery_datetime, 32);
+    const date = /^(\d{4})-(\d{2})-(\d{2})$/.exec(eta);
+    const validEta = date && calendarDay(Number(date[1]), Number(date[2]), Number(date[3]));
+    const latestDay = latest.time ? DateTime.fromISO(latest.time, { setZone: true }).toISODate()
+        : typeof latest.local_time === 'string' ? latest.local_time.slice(0, 10) : null;
+    const heldForDocuments = history.events.some((row) => isRecord(row) && isRecord(row.detail) && row.detail.incident_type_code === '21_INCT');
+    const active = mapped && ['pending', 'in_transit', 'out_for_delivery'].includes(mapped.status) && mapped.stage !== 'ready_for_pickup';
+    // The widget uses the committed date as a calendar estimate. Old estimates
+    // persist after incidents/returns; do not present those as a current promise.
+    const expected = active && latest.provider_leg !== 'return' && !heldForDocuments && validEta && latestDay && validEta >= latestDay ? validEta : null;
+    return { status: returned ? 'exception' : mapped?.status ?? 'unknown', ...(latest.stage ? { current_stage: latest.stage } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null, last_update_local: latest.local_time ?? null,
+        expected_delivery: expected, ...(mapped?.status === 'delivered' && !returned && latest.time ? { delivered_at: latest.time } : {}),
+        events: unique.slice(0, 100) };
+}

package/dist/carriers/ctt-express/status.d.ts

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

package/dist/carriers/ctt-express/status.js

@@ -0,0 +1,17 @@
+const codes = {
+    '0000': { status: 'pending', stage: 'registered' },
+    '0600': { status: 'exception', stage: 'exception' },
+    '1000': { status: 'in_transit', stage: 'in_transit' },
+    '1500': { status: 'out_for_delivery', stage: 'out_for_delivery' },
+    '1600': { status: 'exception', stage: 'exception' },
+    // Actual "Nuevo reparto" scan, grouped with 1500 by the official widget.
+    '2400': { status: 'out_for_delivery', stage: 'out_for_delivery' },
+    '2310': { status: 'in_transit', stage: 'ready_for_pickup' },
+    // The widget explicitly says the parcel is on its way back to the sender.
+    '2500': { status: 'exception', stage: 'exception' },
+    '2100': { status: 'delivered', stage: 'delivered' },
+    '2110': { status: 'delivered', stage: 'delivered' },
+};
+export function classifyCttExpressStatus(code) {
+    return Object.hasOwn(codes, code) ? codes[code] : undefined;
+}

package/dist/carriers/ctt-express/statuses.json

@@ -0,0 +1,15 @@
+{
+  "carrier": "ctt-express",
+  "entries": [
+    { "code": "0000", "wording": "Pendiente de recepción en CTT Express", "language": "es", "stage": "registered", "confirmedBy": "live" },
+    { "code": "0600", "wording": "Recogida fallida", "language": "es", "stage": "exception", "confirmedBy": "live" },
+    { "code": "1000", "wording": "Enviado", "language": "es", "stage": "in_transit", "confirmedBy": "live" },
+    { "code": "1500", "wording": "En reparto", "language": "es", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "1600", "wording": "Incidencia en el reparto", "language": "es", "stage": "exception", "confirmedBy": "live" },
+    { "code": "2400", "wording": "Nuevo reparto", "language": "es", "stage": "out_for_delivery", "confirmedBy": "live" },
+    { "code": "2310", "wording": "Disponible en Punto Collectt Express", "language": "es", "stage": "ready_for_pickup", "confirmedBy": "live" },
+    { "code": "2500", "wording": "En devolución", "language": "es", "stage": "exception", "confirmedBy": "live" },
+    { "code": "2100", "wording": "El envío fue entregado correctamente", "language": "es", "stage": "delivered", "confirmedBy": "portal" },
+    { "code": "2110", "wording": "El envío fue entregado correctamente", "language": "es", "stage": "delivered", "confirmedBy": "portal" }
+  ]
+}

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

@@ -0,0 +1,25 @@
+export { validateDachserTrackingUrl } from '../../core/catalog/urls.js';
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export interface DachserOptions {
+    timeoutMs?: number;
+    /** Test seam; production uses the global fetch. */
+    fetcher?: typeof fetch;
+}
+/**
+ * Validate and canonicalize a pasted Dachser capability URL.
+ *
+ * The host's `carriers.ts` calls this when a parcel is created or edited, so
+ * the failures below are user-facing input errors, not provider errors. The
+ * URL's query parameters grant access to the shipment: treat the whole string
+ * like a password.
+ */
+export declare function dachserApiUrl(trackingUrl: string, trackingNumber: string): string;
+export declare function parseDachserTrackingResponse(payload: unknown, trackingNumber: string): CarrierResult;
+export declare class DachserTracker {
+    #private;
+    readonly timeoutMs: number;
+    constructor(options?: number | DachserOptions);
+    fetch(trackingNumber: string, trackingUrl: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/dachser/adapter.js

@@ -0,0 +1,168 @@
+import { validateDachserTrackingUrl } from '../../core/catalog/urls.js';
+export { validateDachserTrackingUrl } from '../../core/catalog/urls.js';
+import { DateTime } from 'luxon';
+import { InputRequiredError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { eventLabel, plainText, shipmentStatus } from './status.js';
+const DACHSER_HOST = 'customeriberia.dachser.com';
+const DACHSER_PAGE_PATH = '/customerarea/utilidades/seguimiento-publico/detalle';
+const DACHSER_API_PATH = '/api/utilidades/seguimiento-publico/detalle';
+const PROVIDER = 'Dachser';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DATE_FORMATS = [
+    'dd/MM/yyyy HH:mm:ss',
+    'dd/MM/yyyy HH:mm',
+    'dd/MM/yyyy',
+    'yyyy-MM-dd HH:mm:ss',
+    'yyyy-MM-dd HH:mm',
+    'yyyy-MM-dd',
+];
+function normalizeTrackingNumber(raw) {
+    return String(raw ?? '').replace(/[\s.-]/g, '').toUpperCase();
+}
+/**
+ * Validate and canonicalize a pasted Dachser capability URL.
+ *
+ * The host's `carriers.ts` calls this when a parcel is created or edited, so
+ * the failures below are user-facing input errors, not provider errors. The
+ * URL's query parameters grant access to the shipment: treat the whole string
+ * like a password.
+ */
+export function dachserApiUrl(trackingUrl, trackingNumber) {
+    const url = new URL(validateDachserTrackingUrl(trackingUrl, trackingNumber));
+    url.pathname = DACHSER_API_PATH;
+    return url.toString();
+}
+/**
+ * Local time policy: the endpoint mixes ISO-8601 with `dd/MM/yyyy [HH:mm[:ss]]`
+ * and `yyyy-MM-dd [HH:mm[:ss]]`, all of them wall-clock times in Spain. Values
+ * that do carry an offset keep it; everything else is read in Europe/Madrid.
+ */
+function parseDateTime(raw) {
+    const value = String(raw ?? '').trim();
+    if (!value)
+        return null;
+    let parsed = DateTime.fromISO(value, { zone: 'Europe/Madrid', setZone: true });
+    if (!parsed.isValid) {
+        for (const format of DATE_FORMATS) {
+            parsed = DateTime.fromFormat(value, format, { zone: 'Europe/Madrid' });
+            if (parsed.isValid)
+                break;
+        }
+    }
+    return parsed.isValid ? parsed : null;
+}
+export function parseDachserTrackingResponse(payload, trackingNumber) {
+    if (!isRecord(payload))
+        throw new SchemaError(PROVIDER, 'Dachser returned an invalid tracking response');
+    if (!payload.numUnico)
+        throw new SchemaError(PROVIDER, 'Dachser did not return a shipment number');
+    if (normalizeTrackingNumber(payload.numUnico) !== normalizeTrackingNumber(trackingNumber)) {
+        throw new SchemaError(PROVIDER, 'Dachser returned a different shipment');
+    }
+    const sourceEvents = Array.isArray(payload.incidenciaExpedicionData)
+        ? payload.incidenciaExpedicionData
+        : [];
+    const events = [];
+    const seen = new Set();
+    for (const sourceEvent of sourceEvents.slice(0, 200)) {
+        if (!isRecord(sourceEvent))
+            continue;
+        const occurred = parseDateTime(sourceEvent.fechaIncidencia);
+        if (!occurred)
+            continue;
+        const label = eventLabel(sourceEvent.descripcionIncidencia);
+        const timestamp = occurred.toISO({ suppressMilliseconds: true });
+        const identity = JSON.stringify([timestamp, label.stage, label.description]);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        events.push({ time: timestamp, location: '', ...label });
+    }
+    events.sort((left, right) => right.time.localeCompare(left.time));
+    const status = shipmentStatus(payload.estadoExpedicion, events.length > 0);
+    const lastUpdate = parseDateTime(payload.fechaEstado) ?? parseDateTime(events[0]?.time);
+    let expectedDelivery = null;
+    if (status.status !== 'delivered') {
+        for (const field of ['fechaEntregaAplazada', 'fCompromiso', 'fechaPrimeraEntrega']) {
+            const value = parseDateTime(payload[field]);
+            if (value) {
+                expectedDelivery = value.toISODate();
+                break;
+            }
+        }
+    }
+    return {
+        status: status.status,
+        last_status_text: status.text,
+        last_update: lastUpdate?.toISO({ suppressMilliseconds: true }) ?? null,
+        expected_delivery: expectedDelivery,
+        timezone: 'Europe/Madrid',
+        events,
+    };
+}
+export class DachserTracker {
+    timeoutMs;
+    #fetcher;
+    constructor(options = {}) {
+        const { timeoutMs = DEFAULT_TIMEOUT_MS, fetcher } = typeof options === 'number'
+            ? { timeoutMs: options, fetcher: undefined }
+            : options;
+        this.timeoutMs = timeoutMs;
+        this.#fetcher = fetcher;
+    }
+    async fetch(trackingNumber, trackingUrl) {
+        const { bytes, response } = await fetchBounded(dachserApiUrl(trackingUrl, trackingNumber), {
+            headers: {
+                Accept: 'application/json',
+                'Accept-Language': 'en',
+                Referer: `https://${DACHSER_HOST}${DACHSER_PAGE_PATH}`,
+                'User-Agent': 'SwissDeliveryTracker/1.0',
+            },
+        }, {
+            provider: 'Dachser tracking',
+            timeoutMs: this.timeoutMs,
+            allowHttpError: true,
+            ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
+        });
+        if (!response.ok) {
+            if (response.status === 404)
+                throw new NotFoundError(PROVIDER);
+            let errorPayload;
+            try {
+                errorPayload = parseJsonBytes(bytes, PROVIDER);
+            }
+            catch {
+                throw new UpstreamHttpError('Dachser tracking', response.status);
+            }
+            // An unknown shipment/access tuple currently reaches a null result in
+            // Dachser's public endpoint and is surfaced as this stable JSON 500.
+            // Match the public error signature narrowly so unrelated 500s remain
+            // operational failures rather than false not-found results.
+            const errorMessage = plainText(isRecord(errorPayload) ? errorPayload.message ?? '' : '');
+            if (response.status === 500
+                && isRecord(errorPayload)
+                && errorPayload.code === 'ERR_APP_500'
+                && errorPayload.path === DACHSER_API_PATH
+                && errorMessage.includes('resultadodetexp')
+                && errorMessage.includes('null'))
+                throw new NotFoundError(PROVIDER);
+            throw new UpstreamHttpError('Dachser tracking', response.status);
+        }
+        return parseDachserTrackingResponse(parseJsonBytes(bytes, PROVIDER), trackingNumber);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new DachserTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'dachser',
+        steps: ['direct'],
+        track: async (input) => {
+            if (!input.trackingUrl) {
+                throw new InputRequiredError(PROVIDER, 'its complete tracking URL', 'Dachser tracking requires its complete tracking URL');
+            }
+            return tracker.fetch(input.number, input.trackingUrl);
+        },
+    };
+};

package/dist/carriers/dachser/carrier.json

@@ -0,0 +1,80 @@
+{
+  "id": "dachser",
+  "displayName": "Dachser",
+  "aliases": [
+    "Dachser SE",
+    "Dachser Customer Iberia"
+  ],
+  "region": {
+    "countries": [
+      "ES",
+      "PT"
+    ]
+  },
+  "brand": {
+    "color": "#005ca9"
+  },
+  "selectable": true,
+  "timezone": "Europe/Madrid",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "dachser",
+    "requirements": [
+      {
+        "field": "trackingUrl",
+        "validator": "dachserCapabilityUrl",
+        "label": "Dachser tracking URL",
+        "type": "url",
+        "placeholder": "https://customeriberia.dachser.com/customerarea/…",
+        "help": "Paste the complete public detail link, including its access parameters."
+      }
+    ],
+    "steps": [
+      "direct"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "eta"
+  ],
+  "portal": {
+    "canaryUrl": "https://customeriberia.dachser.com/customerarea/",
+    "shows": [
+      "status",
+      "history",
+      "eta",
+      "sender_name",
+      "recipient_name",
+      "recipient_address",
+      "recipient_contact",
+      "signature"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "eta"
+    ],
+    "discarded": [
+      "sender_name",
+      "recipient_name",
+      "recipient_address",
+      "recipient_contact",
+      "signature"
+    ],
+    "unavailable": [
+      "location"
+    ]
+  },
+  "links": [
+    {
+      "domains": [
+        "customeriberia.dachser.com"
+      ],
+      "params": [
+        "numeroUnico"
+      ],
+      "keepsCapabilityUrl": true
+    }
+  ],
+  "detection": []
+}

package/dist/carriers/dachser/numbers.json

@@ -0,0 +1,66 @@
+{
+  "carrier": "dachser",
+  "records": [
+    {
+      "number": "04610654186",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6a21b9515f37085b8ae3d11d",
+        "date": "2026-06-04"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "postlogistics",
+          "gls-ch",
+          "gls-fr",
+          "gls-de",
+          "blue-dart",
+          "aramex"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to Dachser, which no rule claims. Consignment within Spain."
+    },
+    {
+      "number": "4966085731",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://portaldaqueixa.com/brands/dachser-portugal/complaints/dachser-portugal-rececao-de-mensagens-de-encomenda-nao-solicitada-157557926",
+        "date": "2026-06-24"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dhl",
+          "mondial-relay",
+          "relais-colis",
+          "tipsa",
+          "estafeta"
+        ]
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to Dachser, which no rule claims. Consignment number from a delivery SMS the recipient did not expect."
+    },
+    {
+      "number": "9010000001234",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "official_shape",
+      "shapeConfirmed": "2026-09-10",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "la-poste",
+          "correos-chile",
+          "delhivery",
+          "yunda"
+        ]
+      },
+      "note": "Made-up number that follows the published format. Filed under Dachser, which no rule claims."
+    }
+  ]
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Dachser status classification.
+ *
+ * The Customer Iberia endpoint has no status code: it sends a free-text
+ * `descripcionIncidencia` per event and a free-text `estadoExpedicion` for the
+ * shipment, in Spanish and occasionally English, French, German or Italian.
+ * Both classifiers therefore work on accent-folded, lower-cased substrings,
+ * ordered so that negatives and future-dated notices are decided before the
+ * broad delivery words they contain.
+ */
+import type { CarrierResult } from '../../core/result/index.js';
+import type { Stage } from '../../generated/catalog.js';
+/** Lower-cased, accent-free text, for language-independent matching. */
+export declare function plainText(raw: unknown): string;
+interface EventRule {
+    stage: Stage;
+    description: string;
+    needles: string[];
+}
+/**
+ * Event wording rules, in priority order. The first match wins, so
+ * "no entregado" is classified before the "entregado" it contains, and a
+ * rescheduled delivery appointment ("fecha de entrega", "cita") never counts
+ * as a delivery.
+ */
+export declare const EVENT_RULES: readonly EventRule[];
+/** The stage and the neutral English wording we show for one event row. */
+export declare function eventLabel(rawDescription: unknown): {
+    stage: Stage;
+    description: string;
+};
+/**
+ * The shipment-level status. `hasEvents` keeps a shipment with history but no
+ * recognized heading in transit, while a shipment with neither stays unknown.
+ */
+export declare function shipmentStatus(rawStatus: unknown, hasEvents: boolean): {
+    status: CarrierResult['status'];
+    text: string;
+};
+export {};

package/dist/carriers/dachser/status.js

@@ -0,0 +1,57 @@
+/** Lower-cased, accent-free text, for language-independent matching. */
+export function plainText(raw) {
+    return String(raw ?? '')
+        .toLocaleLowerCase()
+        .normalize('NFKD')
+        .replace(/\p{M}/gu, '');
+}
+/**
+ * Event wording rules, in priority order. The first match wins, so
+ * "no entregado" is classified before the "entregado" it contains, and a
+ * rescheduled delivery appointment ("fecha de entrega", "cita") never counts
+ * as a delivery.
+ */
+export const EVENT_RULES = [
+    { stage: 'exception', description: 'Shipment exception', needles: ['incidencia', 'averia', 'danad', 'rechazad', 'direccion incorrecta'] },
+    { stage: 'failed_attempt', description: 'Delivery attempt was unsuccessful', needles: ['no entreg', 'entrega fallida', 'failed delivery', 'unsuccessful'] },
+    { stage: 'returned', description: 'Shipment returned', needles: ['devol', 'retorn', 'return', 'retour'] },
+    { stage: 'in_transit', description: 'Delivery appointment updated', needles: ['fecha de entrega', 'cita', 'appointment', 'avis de livraison'] },
+    { stage: 'delivered', description: 'Delivered', needles: ['entregado', 'entregada', 'delivered', 'zugestellt', 'consegnat'] },
+    { stage: 'out_for_delivery', description: 'Out for delivery', needles: ['reparto', 'proceso de entrega', 'out for delivery', 'in zustellung'] },
+    { stage: 'ready_for_pickup', description: 'Ready for pickup', needles: ['recogida', 'ready for pickup', 'ready for collection', 'abholbereit'] },
+    { stage: 'customs', description: 'Customs processing', needles: ['aduana', 'customs', 'clearance', 'zoll'] },
+    { stage: 'in_transit', description: 'Shipment departed a Dachser facility', needles: ['salida', 'departed', 'outbound'] },
+    { stage: 'in_transit', description: 'Shipment arrived at a Dachser facility', needles: ['llegada', 'arrived', 'inbound'] },
+    { stage: 'accepted', description: 'Shipment accepted by Dachser', needles: ['recogido', 'aceptado', 'picked up', 'accepted'] },
+    { stage: 'registered', description: 'Shipment registered by Dachser', needles: ['registrado', 'creado', 'announced', 'registered', 'information received'] },
+];
+/** The stage and the neutral English wording we show for one event row. */
+export function eventLabel(rawDescription) {
+    const value = plainText(rawDescription);
+    const matched = EVENT_RULES.find((rule) => rule.needles.some((needle) => value.includes(needle)));
+    return matched
+        ? { stage: matched.stage, description: matched.description }
+        : { stage: 'in_transit', description: 'Dachser tracking update' };
+}
+/**
+ * The shipment-level status. `hasEvents` keeps a shipment with history but no
+ * recognized heading in transit, while a shipment with neither stays unknown.
+ */
+export function shipmentStatus(rawStatus, hasEvents) {
+    const value = plainText(rawStatus);
+    if (['no entreg', 'incidencia', 'averia', 'failed', 'problem', 'devol', 'return', 'retour']
+        .some((needle) => value.includes(needle)))
+        return { status: 'exception', text: 'Shipment exception' };
+    if (['entregado', 'entregada', 'delivered', 'zugestellt', 'consegnat']
+        .some((needle) => value.includes(needle)))
+        return { status: 'delivered', text: 'Delivered' };
+    if (['reparto', 'proceso de entrega', 'out for delivery', 'in zustellung']
+        .some((needle) => value.includes(needle)))
+        return { status: 'out_for_delivery', text: 'Out for delivery' };
+    if (['registrado', 'creado', 'announced', 'registered', 'information received']
+        .some((needle) => value.includes(needle)))
+        return { status: 'pending', text: 'Shipment registered by Dachser' };
+    if (value || hasEvents)
+        return { status: 'in_transit', text: 'In transit' };
+    return { status: 'unknown', text: 'Tracking update unavailable' };
+}

package/dist/carriers/dachser/statuses.json

@@ -0,0 +1,18 @@
+{
+  "carrier": "dachser",
+  "entries": [
+    { "wording": "no entreg… / entrega fallida / failed delivery / unsuccessful", "language": "mul", "stage": "failed_attempt", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "Checked before every delivery word, because 'no entregado' contains 'entregado'." },
+    { "wording": "incidencia / averia / dañad… / rechazad… / dirección incorrecta", "language": "mul", "stage": "exception", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Checked before the failed-attempt rule. Reclassified to exception 2026-09-12." },
+    { "wording": "devol… / retorn… / return / retour", "language": "mul", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "fecha de entrega / cita / appointment / avis de livraison", "language": "mul", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "A rescheduled delivery appointment is a future date, never a delivery." },
+    { "wording": "entregado / entregada / delivered / zugestellt / consegnat…", "language": "mul", "stage": "delivered", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "reparto / proceso de entrega / out for delivery / in Zustellung", "language": "mul", "stage": "out_for_delivery", "confirmedBy": "prior-art", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "recogida / ready for pickup / ready for collection / abholbereit", "language": "mul", "stage": "ready_for_pickup", "confirmedBy": "prior-art", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "aduana / customs / clearance / Zoll", "language": "mul", "stage": "customs", "confirmedBy": "prior-art", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "salida / departed / outbound", "language": "mul", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "Reported as 'Shipment departed a Dachser facility'." },
+    { "wording": "llegada / arrived / inbound", "language": "mul", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "Reported as 'Shipment arrived at a Dachser facility'." },
+    { "wording": "recogido / aceptado / picked up / accepted", "language": "mul", "stage": "accepted", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "registrado / creado / announced / registered / information received", "language": "mul", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-09-10", "note": "" },
+    { "wording": "any other event wording", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-10", "note": "Reported as 'Dachser tracking update'; the raw Spanish wording is not retained." }
+  ]
+}

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

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