universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/sunyou/adapter.js

@@ -0,0 +1,156 @@
+/**
+ * SunYou tracking.
+ *
+ * `sypost.net/queryTrack` is the keyless endpoint the public search page uses.
+ * It answers with JSONP (`callbackName({...})`) rather than JSON and expects a
+ * cache-busting `queryTime`, so the body is unwrapped before it is parsed.
+ *
+ * A shipment is returned in two legs — `result.origin` and
+ * `result.destination` — each stamping its own timezone. Events are merged and
+ * ordered by absolute instant, never by comparing wall-clock strings across
+ * legs.
+ */
+import { randomInt } from 'node:crypto';
+import { DateTime } from 'luxon';
+import { NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { decodeText, fetchBounded } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { sunYouStatus } from './status.js';
+const PROVIDER = 'SunYou';
+const UPSTREAM = 'SunYou tracking';
+const QUERY_URL = 'https://sypost.net/queryTrack';
+const JSONP_ENVELOPE = /^\s*\w+\(([\s\S]*)\)\s*;?\s*$/;
+const EXPLICIT_OFFSET = /(?:Z|[+-]\d{2}:?\d{2})$/;
+const LEG_OFFSET = /^([+-])(\d{2}):?(\d{2})$/;
+const MAX_EVENTS_TO_RETURN = 20;
+const BASE_HEADERS = {
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'User-Agent': 'Mozilla/5.0 (compatible; SwissDeliveryTracker/1.0)',
+};
+function record(value) {
+    return isRecord(value) ? value : {};
+}
+function recordArray(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function text(value) {
+    return typeof value === 'string' ? value : '';
+}
+function comparableIdentifier(value) {
+    return text(value).toLocaleUpperCase('en-US').replace(/[^A-Z0-9]/g, '');
+}
+/**
+ * The event's timestamp, with the leg's offset applied when the provider gives
+ * one. This is not `core/time`'s `explicitOffsetTime`: that policy rejects a
+ * value it cannot resolve, while SunYou's provider text must pass through
+ * unchanged instead of disappearing — a naive string is still the only thing
+ * the carrier said about that scan, and inventing a zone would be worse.
+ */
+function sunYouEventTime(event) {
+    const raw = text(event.createTime);
+    if (!raw || EXPLICIT_OFFSET.test(raw))
+        return raw;
+    // Origin/destination legs stamp their own zone (observed "+08:00" on origin
+    // scans of a captured SYAE shipment). Honor an explicit offset instead of
+    // comparing wall-clock strings across legs; without a usable offset the
+    // provider text passes through unchanged — never invented.
+    const zone = LEG_OFFSET.exec(text(event.timeZone));
+    if (!zone)
+        return raw;
+    const parsed = DateTime.fromISO(`${raw.replace(' ', 'T')}${zone[1]}${zone[2]}:${zone[3]}`, { setZone: true });
+    return parsed.isValid ? parsed.toISO({ suppressMilliseconds: true }) ?? raw : raw;
+}
+function sunYouEventInstant(event) {
+    // fromISO needs the T separator; provider wall-clock strings use a space.
+    const parsed = DateTime.fromISO(sunYouEventTime(event).replace(' ', 'T'), { setZone: true });
+    return parsed.isValid ? parsed.toMillis() : Number.NEGATIVE_INFINITY;
+}
+/** Unwraps the JSONP envelope the search page receives. */
+export function parseSunYouEnvelope(body) {
+    const match = JSONP_ENVELOPE.exec(body);
+    if (!match) {
+        throw new SchemaError(PROVIDER, 'SunYou returned an invalid tracking response');
+    }
+    try {
+        return JSON.parse(match[1]);
+    }
+    catch (error) {
+        throw new SchemaError(PROVIDER, 'SunYou returned an invalid tracking response', { cause: error });
+    }
+}
+/** Projects one unwrapped payload. Pure: the offline tests target this. */
+export function parseSunYouTrackingResponse(value, trackingNumber) {
+    const payload = record(value);
+    if (!Array.isArray(payload.data)) {
+        throw new SchemaError(PROVIDER, 'SunYou returned an invalid tracking response');
+    }
+    const items = recordArray(payload.data);
+    if (items.length !== payload.data.length) {
+        throw new SchemaError(PROVIDER, 'SunYou returned an invalid shipment entry');
+    }
+    if (items.length === 0)
+        throw new SchemaError(PROVIDER, 'SunYou did not return a shipment entry');
+    const requested = comparableIdentifier(trackingNumber);
+    const identified = items.filter((candidate) => comparableIdentifier(candidate.orderNo));
+    if (identified.length === 0)
+        throw new SchemaError(PROVIDER, 'SunYou did not return a shipment identifier');
+    const item = identified.find((candidate) => comparableIdentifier(candidate.orderNo) === requested);
+    if (!item)
+        throw new SchemaError(PROVIDER, 'SunYou returned a different shipment');
+    const displayStatus = String(item.displayStatus ?? '');
+    if (displayStatus === '0')
+        throw new NotFoundError(PROVIDER);
+    if (item.has !== true)
+        throw new NotFoundError(PROVIDER);
+    const result = record(item.result);
+    const allEvents = [
+        ...recordArray(record(result.origin).items),
+        ...recordArray(record(result.destination).items),
+    ].sort((left, right) => sunYouEventInstant(right) - sunYouEventInstant(left));
+    const classified = sunYouStatus(displayStatus);
+    const events = allEvents.slice(0, MAX_EVENTS_TO_RETURN).map((event, index) => ({
+        time: sunYouEventTime(event),
+        location: '',
+        description: text(event.content),
+        ...(index === 0 && classified ? { stage: classified.stage } : {}),
+    }));
+    return {
+        status: classified?.status ?? 'in_transit',
+        ...(classified ? { current_stage: classified.stage } : {}),
+        last_status_text: text(item.lastContent) || events[0]?.description || '',
+        last_update: text(item.lastUpdate) || events[0]?.time || null,
+        expected_delivery: null,
+        events,
+    };
+}
+export class SunYouTracker {
+    fetcher;
+    timeoutMs;
+    constructor(options = {}) {
+        this.fetcher = options.fetcher;
+        this.timeoutMs = options.timeoutMs;
+    }
+    async fetch(trackingNumber) {
+        const queryTime = `${Date.now()}-${randomInt(10_000, 100_000)}`;
+        const { bytes } = await fetchBounded(`${QUERY_URL}?${new URLSearchParams({
+            queryTime,
+            toLanguage: 'en_US',
+            trackNumber: trackingNumber,
+        })}`, { headers: { ...BASE_HEADERS, Referer: 'https://sypost.net/search' } }, { provider: UPSTREAM, ...(this.timeoutMs === undefined ? {} : { timeoutMs: this.timeoutMs }), fetcher: this.fetcher });
+        return parseSunYouTrackingResponse(parseSunYouEnvelope(decodeText(bytes)), trackingNumber);
+    }
+}
+/** Kept for the host's legacy dispatch chain until it is deleted. */
+export async function fetchSunYou(trackingNumber) {
+    return new SunYouTracker().fetch(trackingNumber);
+}
+export const adapter = (environment) => {
+    const tracker = new SunYouTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'sunyou',
+        // One keyless GET; there is no second tier to fall back to.
+        steps: ['direct'],
+        track: (input) => tracker.fetch(input.number),
+    };
+};

package/dist/carriers/sunyou/carrier.json

@@ -0,0 +1,64 @@
+{
+  "id": "sunyou",
+  "displayName": "SunYou",
+  "aliases": [
+    "SYPost"
+  ],
+  "region": {
+    "countries": [
+      "CN"
+    ]
+  },
+  "brand": {
+    "color": "#f39800"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "sunyou",
+    "steps": [
+      "direct"
+    ]
+  },
+  "capabilities": [
+    "history"
+  ],
+  "portal": {
+    "url": "https://sypost.net/search?orderNo={trackingNumber}",
+    "canaryUrl": "https://sypost.net/",
+    "shows": [
+      "status",
+      "history"
+    ],
+    "scraped": [
+      "status",
+      "history"
+    ],
+    "discarded": [],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "sypost.net"
+      ],
+      "params": [
+        "orderNo",
+        "trackNumber"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "sunyou-1",
+      "pattern": "^SY\\d{11}$",
+      "confidence": "high"
+    },
+    {
+      "id": "sunyou-2",
+      "pattern": "^SYAE\\d{9}$",
+      "confidence": "high"
+    }
+  ]
+}

package/dist/carriers/sunyou/numbers.json

@@ -0,0 +1,44 @@
+{
+  "carrier": "sunyou",
+  "records": [
+    {
+      "number": "SY12345678901",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "official_shape",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "sunyou",
+        "confidence": "high"
+      },
+      "note": "Made-up number that follows the published format."
+    },
+    {
+      "number": "SYAE006809461",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://github.com/ha-parcel-integrations/ha-sunyou/blob/main/tests/payloads.py",
+        "date": "2021-07-20"
+      },
+      "expect": {
+        "carrier": "sunyou",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    },
+    {
+      "number": "SYAE100000001",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/ha-parcel-integrations/ha-sunyou/blob/main/tests/payloads.py"
+      },
+      "expect": {
+        "carrier": "sunyou",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    }
+  ]
+}

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

@@ -0,0 +1,17 @@
+/**
+ * SunYou status vocabulary.
+ *
+ * The tracking endpoint returns one numeric `displayStatus` per shipment; the
+ * scan texts themselves carry no code. `0` is not in the map: it is SunYou's
+ * explicit "no such shipment" and the adapter turns it into a not-found before
+ * classification.
+ *
+ * Only the newest scan inherits this stage. Older scans are returned without
+ * one, because the shipment-level status says nothing about where the parcel
+ * was three days ago.
+ */
+import type { ClassifiedStatus } from '../../core/status/index.js';
+declare const DISPLAY_STATUS: Map<string, ClassifiedStatus>;
+export { DISPLAY_STATUS as SUNYOU_STATUS };
+/** The status and stage for one `displayStatus`, or undefined when unmapped. */
+export declare function sunYouStatus(displayStatus: string): ClassifiedStatus | undefined;

package/dist/carriers/sunyou/status.js

@@ -0,0 +1,13 @@
+const DISPLAY_STATUS = new Map([
+    ['1', { status: 'in_transit', stage: 'in_transit' }],
+    ['2', { status: 'out_for_delivery', stage: 'ready_for_pickup' }],
+    ['3', { status: 'exception', stage: 'failed_attempt' }],
+    ['4', { status: 'delivered', stage: 'delivered' }],
+    ['5', { status: 'exception', stage: 'failed_attempt' }],
+    ['6', { status: 'exception', stage: 'failed_attempt' }],
+]);
+export { DISPLAY_STATUS as SUNYOU_STATUS };
+/** The status and stage for one `displayStatus`, or undefined when unmapped. */
+export function sunYouStatus(displayStatus) {
+    return DISPLAY_STATUS.get(displayStatus);
+}

package/dist/carriers/sunyou/statuses.json

@@ -0,0 +1,53 @@
+{
+  "carrier": "sunyou",
+  "entries": [
+    {
+      "code": "0",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Explicit \"no such shipment\"; reported as a clean 404 and never classified."
+    },
+    {
+      "code": "1",
+      "stage": "in_transit",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment-level display status; only the newest scan inherits it."
+    },
+    {
+      "code": "2",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Waiting at a pickup point."
+    },
+    {
+      "code": "3",
+      "stage": "failed_attempt",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment-level display status; only the newest scan inherits it."
+    },
+    {
+      "code": "4",
+      "stage": "delivered",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment-level display status; only the newest scan inherits it."
+    },
+    {
+      "code": "5",
+      "stage": "failed_attempt",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment-level display status; only the newest scan inherits it."
+    },
+    {
+      "code": "6",
+      "stage": "failed_attempt",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-12",
+      "note": "Shipment-level display status; only the newest scan inherits it."
+    }
+  ]
+}

package/dist/carriers/swiss-post/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+import { type JsonObject } from '../../core/types.js';
+export interface SwissPostOptions {
+    /** Test seam; production uses the global fetch. The cookie jar wraps it. */
+    fetcher?: typeof fetch;
+}
+export declare function swissPostExpectedDelivery(item: JsonObject): string | null;
+export declare function parseSwissPostShipment(item: JsonObject, rawEvents: unknown[], translations?: Record<string, string>): CarrierResult;
+export declare class SwissPostTracker {
+    #private;
+    constructor(options?: SwissPostOptions);
+    readJson(fetcher: typeof fetch, url: string, init?: RequestInit): Promise<unknown>;
+    /** Cached for the process: the table is large, static, and shared by every lookup. */
+    loadTranslations(fetcher: typeof fetch): Promise<Record<string, string>>;
+    fetch(trackingNumber: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/swiss-post/adapter.js

@@ -0,0 +1,282 @@
+import { load } from 'cheerio';
+import makeFetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+import { NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { FALLBACK_EVENT_LABELS, STAGE_STATUS, STATUS_MAP, swissPostEventStage } from './status.js';
+// The public tracker signs an anonymous visitor in before it will search: it
+// creates a throwaway user, echoes a CSRF token, and keys the search result on
+// a hash. Every call in that sequence shares one cookie jar.
+const API_BASE = 'https://service.post.ch/ekp-web/api';
+const TRANSLATIONS_URL = 'https://service.post.ch/ekp-web/core/rest/translations/en/shipment-text-messages';
+const PROVIDER = 'Swiss Post';
+const HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/121.0.0.0 Safari/537.36',
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-CH,en;q=0.9',
+    Referer: 'https://service.post.ch/ekp-web/ui/',
+};
+/**
+ * Trim and cap without collapsing inner whitespace: Swiss Post's translated
+ * wording is shown as the carrier writes it, so `core/transport`'s `clean` is
+ * deliberately not used here.
+ */
+function text(value, limit = 500) {
+    return String(value ?? '').trim().slice(0, limit);
+}
+function comparableShipmentNumber(value) {
+    return String(value ?? '').replace(/[\s.-]/g, '').toUpperCase();
+}
+function datePart(value) {
+    return /(?<!\d)(\d{4}-\d{2}-\d{2})(?!\d)/.exec(text(value))?.[1] ?? null;
+}
+function clockParts(value) {
+    if (isRecord(value)) {
+        return ['start', 'end', 'from', 'to'].flatMap((key) => clockParts(value[key]));
+    }
+    if (Array.isArray(value))
+        return value.flatMap(clockParts);
+    const stringValue = text(value);
+    const timestampClock = /T((?:[01]\d|2[0-3]):[0-5]\d)/.exec(stringValue)?.[1];
+    if (timestampClock)
+        return [timestampClock];
+    const clocks = stringValue.match(/(?<!\d)(?:[01]\d|2[0-3]):[0-5]\d/g) ?? [];
+    if (clocks.length > 1 && /[+-](?:[01]\d|2[0-3]):[0-5]\d$/.test(stringValue)) {
+        return clocks.slice(0, 1);
+    }
+    return clocks;
+}
+export function swissPostExpectedDelivery(item) {
+    const interval = item.deliveryTimeInterval;
+    const range = isRecord(item.deliveryRange) ? item.deliveryRange : {};
+    const date = [
+        item.calculatedDeliveryDate,
+        item.deliveryDate,
+        interval,
+        range.start,
+        range.end,
+    ].map(datePart).find(Boolean) ?? null;
+    if (!date)
+        return null;
+    const clocks = clockParts(interval);
+    if (clocks.length === 0)
+        return date;
+    if (clocks.length === 1 || clocks[0] === clocks[1])
+        return `${date} ${clocks[0]}`;
+    return `${date} ${clocks[0]}–${clocks[1]}`;
+}
+/**
+ * Resolve one dotted translation key against the service's pattern table, where
+ * `*` is a wildcard segment. The most specific pattern of the same length wins.
+ */
+function translationMatch(translations, segments) {
+    let best = null;
+    for (const [pattern, description] of Object.entries(translations)) {
+        const patternSegments = pattern.split('.');
+        if (patternSegments.length !== segments.length)
+            continue;
+        if (!patternSegments.every((expected, index) => expected === '*' || expected === segments[index])) {
+            continue;
+        }
+        const score = patternSegments.filter((segment) => segment !== '*').length;
+        if (!best || score > best.score)
+            best = { score, description };
+    }
+    return best?.description ?? null;
+}
+function eventDescription(event, translations, internationalType) {
+    const eventCode = text(event.eventCode, 100);
+    const segments = [...eventCode.split('.'), internationalType];
+    let description = translationMatch(translations, segments);
+    const subEventId = text(event.subEventId, 50);
+    if (subEventId) {
+        const subSegments = [...segments, subEventId];
+        const detailCode = text(event.subEventDetailCode, 50);
+        if (detailCode)
+            subSegments.push(detailCode);
+        const detail = translationMatch(translations, subSegments);
+        if (detail && detail !== description)
+            description = description ? `${description} — ${detail}` : detail;
+    }
+    const metadata = isRecord(event.externalMetadata) ? event.externalMetadata : {};
+    const externalDescription = text(metadata.description);
+    const code = eventCode.split('.').at(-1) ?? '';
+    const value = description || externalDescription || FALLBACK_EVENT_LABELS[code] || eventCode;
+    const $ = load(`<span>${value}</span>`);
+    return $('span').text().trim().slice(0, 500) || 'Tracking update';
+}
+/** Operational scan location only: the city and its postcode, never a street. */
+function eventLocation(event) {
+    return [text(event.city, 100), text(event.zip, 30)].filter(Boolean).join(' ').slice(0, 160);
+}
+/**
+ * Local ordering policy: event timestamps are read only to sort. Values without
+ * an offset are treated as UTC for that comparison, which keeps the ordering
+ * stable without rewriting the string the carrier sent — the event keeps the
+ * carrier's own `timestamp` verbatim.
+ */
+function timestamp(value) {
+    const explicitZone = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(value);
+    const parsed = Date.parse(explicitZone ? value : `${value}Z`);
+    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+export function parseSwissPostShipment(item, rawEvents, translations = {}) {
+    const globalStatus = text(item.globalStatus, 100);
+    let status = STATUS_MAP.get(globalStatus) ?? 'in_transit';
+    const internationalType = item.internationalImport
+        ? 'IMPORT'
+        : item.internationalExport
+            ? 'EXPORT'
+            : 'INLAND';
+    const events = [];
+    for (const rawEvent of rawEvents.slice(0, 100)) {
+        if (!isRecord(rawEvent))
+            continue;
+        const time = text(rawEvent.timestamp, 100);
+        const eventCode = text(rawEvent.eventCode, 100);
+        if (!time || !eventCode)
+            continue;
+        const event = {
+            time,
+            location: eventLocation(rawEvent),
+            description: eventDescription(rawEvent, translations, internationalType),
+            provider_code: eventCode,
+        };
+        const stage = swissPostEventStage(eventCode);
+        if (stage)
+            event.stage = stage;
+        events.push(event);
+    }
+    events.sort((left, right) => timestamp(right.time ?? '') - timestamp(left.time ?? ''));
+    let lastStatusText;
+    let lastUpdate;
+    if (events[0]) {
+        lastStatusText = events[0].description ?? 'Tracking update';
+        if (events[0].stage && STAGE_STATUS[events[0].stage])
+            status = STAGE_STATUS[events[0].stage];
+        lastUpdate = events[0].time ?? null;
+    }
+    else {
+        lastStatusText = globalStatus;
+        lastUpdate = text(item.lastEventDateTime, 100) || null;
+    }
+    return {
+        status,
+        ...(events[0]?.stage ? { current_stage: events[0].stage } : {}),
+        last_status_text: lastStatusText,
+        last_update: lastUpdate,
+        expected_delivery: swissPostExpectedDelivery(item),
+        timezone: 'Europe/Zurich',
+        global_status: globalStatus,
+        canonical_tracking_number: comparableShipmentNumber(item.shipmentNumber) || undefined,
+        ...(/^[A-Z0-9]{4,40}$/.test(comparableShipmentNumber(item.internationalBarcode))
+            ? { international_tracking_number: comparableShipmentNumber(item.internationalBarcode) } : {}),
+        delivery_range: item.deliveryRange,
+        delivery_time_interval: item.deliveryTimeInterval,
+        events,
+    };
+}
+export class SwissPostTracker {
+    #translations = null;
+    #translationAttempted = false;
+    #fetcher;
+    constructor(options = {}) {
+        this.#fetcher = options.fetcher;
+    }
+    async readJson(fetcher, url, init = {}) {
+        const { bytes } = await fetchBounded(url, init, {
+            provider: 'Swiss Post tracking',
+            timeoutMs: 10_000,
+            fetcher,
+        });
+        return parseJsonBytes(bytes, PROVIDER);
+    }
+    /** Cached for the process: the table is large, static, and shared by every lookup. */
+    async loadTranslations(fetcher) {
+        if (this.#translations)
+            return this.#translations;
+        if (this.#translationAttempted)
+            return {};
+        this.#translationAttempted = true;
+        try {
+            const payload = await this.readJson(fetcher, TRANSLATIONS_URL, { headers: HEADERS });
+            const raw = isRecord(payload) && isRecord(payload['shipment-text--'])
+                ? payload['shipment-text--']
+                : {};
+            this.#translations = Object.fromEntries(Object.entries(raw).filter((entry) => typeof entry[1] === 'string'));
+        }
+        catch {
+            return {};
+        }
+        return this.#translations;
+    }
+    async fetch(trackingNumber) {
+        const fetcher = makeFetchCookie(this.#fetcher ?? fetch, new CookieJar());
+        const userResult = await fetchBounded(`${API_BASE}/user`, { headers: HEADERS }, {
+            provider: 'Swiss Post tracking',
+            timeoutMs: 10_000,
+            fetcher,
+        });
+        const userPayload = parseJsonBytes(userResult.bytes, PROVIDER);
+        if (!isRecord(userPayload))
+            throw new SchemaError(PROVIDER, 'Swiss Post returned an invalid anonymous user response');
+        const userId = text(userPayload.userIdentifier);
+        if (!userId)
+            throw new SchemaError(PROVIDER, 'Swiss Post did not return an anonymous user identifier');
+        const csrf = userResult.response.headers.get('x-csrf-token') ?? '';
+        const headers = { ...HEADERS, 'x-csrf-token': csrf };
+        const query = new URLSearchParams({ userId });
+        const historyPayload = await this.readJson(fetcher, `${API_BASE}/history?${query}`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ searchQuery: trackingNumber }),
+        });
+        const hash = isRecord(historyPayload) ? text(historyPayload.hash) : '';
+        if (!hash)
+            throw new SchemaError(PROVIDER, 'Swiss Post did not return a shipment search identifier');
+        const items = await this.readJson(fetcher, `${API_BASE}/history/not-included/${encodeURIComponent(hash)}?${query}`, { headers });
+        if (!Array.isArray(items)) {
+            throw new SchemaError(PROVIDER, 'Swiss Post returned an invalid shipment response');
+        }
+        if (items.length === 0)
+            throw new NotFoundError(PROVIDER);
+        if (!items.every(isRecord)) {
+            throw new SchemaError(PROVIDER, 'Swiss Post returned an invalid shipment response');
+        }
+        const requested = comparableShipmentNumber(trackingNumber);
+        const identified = items.filter((candidate) => comparableShipmentNumber(candidate.shipmentNumber));
+        if (identified.length === 0) {
+            throw new SchemaError(PROVIDER, 'Swiss Post did not return a shipment identifier');
+        }
+        const matches = identified.filter((candidate) => comparableShipmentNumber(candidate.shipmentNumber) === requested
+            || comparableShipmentNumber(candidate.internationalBarcode) === requested);
+        if (matches.length === 0)
+            throw new SchemaError(PROVIDER, 'Swiss Post returned a different shipment');
+        if (matches.length !== 1)
+            throw new SchemaError(PROVIDER, 'Swiss Post returned an ambiguous shipment');
+        const item = matches[0];
+        const identity = text(item.identity);
+        let events = [];
+        if (identity) {
+            try {
+                const payload = await this.readJson(fetcher, `${API_BASE}/shipment/id/${encodeURIComponent(identity)}/events`, { headers });
+                if (Array.isArray(payload))
+                    events = payload;
+            }
+            catch {
+                // A shipment summary is still useful when the optional event call fails.
+            }
+        }
+        const translations = events.length > 0 ? await this.loadTranslations(fetcher) : {};
+        return parseSwissPostShipment(item, events, translations);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new SwissPostTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'swiss-post',
+        steps: ['direct'],
+        track: (input) => tracker.fetch(input.number),
+    };
+};