universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/posti/adapter.js

@@ -0,0 +1,195 @@
+import { CarrierError, IndeterminateError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { postiEventStage, postiStatus } from './status.js';
+const TOKEN_URL = 'https://auth-service.posti.fi/api/v1/anonymous_token';
+const GRAPHQL_URL = 'https://graphql.posti.fi/graphql';
+const DEFAULT_TIMEOUT_MS = 15_000;
+// The public tracking page uses this operation with PUBLIC_SHIPMENTS. Select
+// only tracking fields; no account, recipient, address, payment or pickup code.
+const QUERY = `query SearchShipments($searchTerms: [String!]!, $locale: String) {
+  consumerSearchShipments(page: 1, pageSize: 20, type: PUBLIC_SHIPMENTS, searchTerms: $searchTerms, locale: $locale) {
+    totalHits
+    hits {
+      displayId
+      status { main subStatus }
+      measurements { weight { unit value } height { unit value } width { unit value } length { unit value } }
+      pickupPoint { address { publicName city } }
+      events { city eventDescription reasonDescription timestamp }
+      packages { trackingNumber }
+    }
+  }
+}`;
+export function normalizePostiTrackingNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^[A-Z0-9]{4,40}$/.test(number))
+        throw new TypeError('Posti requires a 4–40 character tracking number');
+    return number;
+}
+class PostiSessionExpiredError extends CarrierError {
+    constructor() {
+        super('indeterminate', 'Posti', 'Posti anonymous session expired');
+        this.name = 'PostiSessionExpiredError';
+    }
+}
+function assertGraphql(payload) {
+    if (!isRecord(payload))
+        throw new SchemaError('Posti');
+    if (Array.isArray(payload.errors) && payload.errors.length > 0) {
+        if (payload.errors.some((error) => isRecord(error) && error.errorType === 'Unauthorized')) {
+            throw new PostiSessionExpiredError();
+        }
+        throw new IndeterminateError('Posti', 'Posti could not complete the tracking query');
+    }
+    if (payload.errors != null && !Array.isArray(payload.errors))
+        throw new SchemaError('Posti');
+}
+function measurement(raw, units) {
+    if (!isRecord(raw) || typeof raw.unit !== 'string' || !Object.hasOwn(units, raw.unit.toLowerCase()))
+        return null;
+    if (typeof raw.value !== 'number' && (typeof raw.value !== 'string' || !raw.value.trim()))
+        return null;
+    const value = Number(raw.value) * units[raw.unit.toLowerCase()];
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+/** Identity-bound projection; empty search, malformed replies and wrong identities remain distinct. */
+export function parse(payload, trackingNumber) {
+    const requested = normalizePostiTrackingNumber(trackingNumber);
+    assertGraphql(payload);
+    const search = isRecord(payload.data) ? payload.data.consumerSearchShipments : undefined;
+    if (!isRecord(search) || !Number.isSafeInteger(search.totalHits) || Number(search.totalHits) < 0
+        || !Array.isArray(search.hits))
+        throw new SchemaError('Posti');
+    if (search.totalHits === 0 && search.hits.length === 0)
+        throw new NotFoundError('Posti');
+    if (search.hits.length === 0 || search.totalHits === 0)
+        throw new SchemaError('Posti');
+    const matches = search.hits.filter((hit) => isRecord(hit) && clean(hit.displayId, 64).toUpperCase() === requested);
+    if (matches.length !== 1 || !isRecord(matches[0]))
+        throw new SchemaError('Posti', 'Posti returned a different or ambiguous shipment');
+    const hit = matches[0];
+    if (!isRecord(hit.status) || typeof hit.status.main !== 'string'
+        || !Array.isArray(hit.status.subStatus) || !hit.status.subStatus.every((code) => typeof code === 'string')
+        || !Array.isArray(hit.events))
+        throw new SchemaError('Posti');
+    // A group overview can contain several parcels. Do not attribute another
+    // parcel's delivered scan to this identity.
+    if (hit.packages != null && !Array.isArray(hit.packages))
+        throw new SchemaError('Posti');
+    const packages = Array.isArray(hit.packages) ? hit.packages : [];
+    if (packages.some((item) => !isRecord(item) || clean(item.trackingNumber, 64).toUpperCase() !== requested)) {
+        throw new SchemaError('Posti', 'Posti returned a multi-parcel overview');
+    }
+    const events = hit.events.map((event) => {
+        if (!isRecord(event) || typeof event.eventDescription !== 'string')
+            throw new SchemaError('Posti');
+        const description = clean(event.eventDescription);
+        return {
+            description: [description, clean(event.reasonDescription)].filter(Boolean).join(' '),
+            time: explicitOffsetTime(event.timestamp)?.iso ?? '',
+            location: clean(event.city, 160),
+            stage: postiEventStage(description),
+        };
+    }).sort((left, right) => (Date.parse(right.time || '') || 0) - (Date.parse(left.time || '') || 0)).slice(0, 100);
+    const current = postiStatus(hit.status.main, hit.status.subStatus);
+    const measurements = isRecord(hit.measurements) ? hit.measurements : {};
+    const dimensions = ['length', 'width', 'height'].map((field) => measurement(measurements[field], { cm: 1, mm: 0.1, m: 100 }));
+    const pickup = isRecord(hit.pickupPoint) && isRecord(hit.pickupPoint.address) ? hit.pickupPoint.address : {};
+    return {
+        status: current?.status ?? 'unknown',
+        ...(current ? { current_stage: current.stage } : {}),
+        last_status_text: events[0]?.description || hit.status.main,
+        last_update: events[0]?.time || null,
+        provider_status: hit.status.main,
+        weight_kg: measurement(measurements.weight, { kg: 1, g: 0.001 }),
+        dimensions_text: dimensions.every((value) => value !== null) ? `${dimensions.join(' × ')} cm` : null,
+        pickup_point: [clean(pickup.publicName, 160), clean(pickup.city, 80)].filter(Boolean).join(', ') || null,
+        timezone: 'Europe/Helsinki',
+        events,
+    };
+}
+function expiry(token) {
+    try {
+        const claims = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString());
+        return isRecord(claims) && typeof claims.exp === 'number' && Number.isFinite(claims.exp) ? claims.exp * 1000 : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export class PostiTracker {
+    options;
+    session;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(trackingNumber, context = {}) {
+        const number = normalizePostiTrackingNumber(trackingNumber);
+        const budgetMs = context.budgetMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        if (!Number.isFinite(budgetMs) || budgetMs <= 0)
+            throw new TypeError('Posti timeout must be positive');
+        const deadline = performance.now() + budgetMs;
+        const request = async (url, init, step) => {
+            step.signal.throwIfAborted();
+            const { bytes } = await fetchBounded(url, init, {
+                provider: 'Posti', maxBytes: 2_000_000,
+                timeoutMs: Math.max(1, Math.floor(deadline - performance.now())),
+                fetcher: (input, options) => (this.options.fetcher ?? fetch)(input, {
+                    ...options, signal: AbortSignal.any([step.signal, ...(options?.signal ? [options.signal] : [])]),
+                }),
+            });
+            return parseJsonBytes(bytes, 'Posti');
+        };
+        const lookup = async (step, refresh = false) => {
+            if (refresh || !this.session || this.session.expiresAt <= Date.now() + 30_000) {
+                this.session = undefined;
+                const token = await request(TOKEN_URL, { method: 'POST' }, step);
+                const role = isRecord(token) && Array.isArray(token.role_tokens)
+                    ? token.role_tokens.find((value) => isRecord(value) && value.type === 'anonymous') : undefined;
+                if (!isRecord(token) || typeof token.id_token !== 'string' || !token.id_token
+                    || !isRecord(role) || typeof role.token !== 'string' || !role.token) {
+                    throw new SchemaError('Posti', 'Posti returned an invalid anonymous session');
+                }
+                this.session = { authorization: role.token, idToken: token.id_token,
+                    expiresAt: Math.min(expiry(role.token), expiry(token.id_token)) };
+            }
+            const session = this.session;
+            let payload;
+            try {
+                payload = await request(GRAPHQL_URL, {
+                    method: 'POST', headers: {
+                        'Content-Type': 'application/json', Accept: 'application/json',
+                        Authorization: session.authorization, 'X-Posti-Token': `Bearer ${session.idToken}`,
+                    },
+                    body: JSON.stringify({ operationName: 'SearchShipments', query: QUERY, variables: { searchTerms: [number], locale: 'en' } }),
+                }, step);
+            }
+            catch (error) {
+                if (error instanceof UpstreamHttpError && [401, 403].includes(error.status)) {
+                    if (this.session === session)
+                        this.session = undefined;
+                    throw new PostiSessionExpiredError();
+                }
+                throw error;
+            }
+            try {
+                return parse(payload, number);
+            }
+            catch (error) {
+                if (error instanceof PostiSessionExpiredError && this.session === session)
+                    this.session = undefined;
+                throw error;
+            }
+        };
+        return runSteps({ carrier: 'posti', budgetMs, signal: context.signal, recorder: this.options.recorder }, [
+            { id: 'direct', run: (step) => lookup(step) },
+            { id: 'refresh', recovers: (error) => error instanceof PostiSessionExpiredError, run: (step) => lookup(step, true) },
+        ]);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new PostiTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'posti', recordsSteps: true, steps: ['direct', 'refresh'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/posti/carrier.json

@@ -0,0 +1,69 @@
+{
+  "id": "posti",
+  "displayName": "Posti",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "FI"
+    ]
+  },
+  "brand": {
+    "color": "#ff8000"
+  },
+  "selectable": true,
+  "timezone": "Europe/Helsinki",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "posti",
+    "steps": [
+      "direct",
+      "refresh"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "weight",
+    "dimensions",
+    "pickup_point"
+  ],
+  "portal": {
+    "url": "https://www.posti.fi/en/tracking/{trackingNumber}",
+    "canaryUrl": "https://www.posti.fi/en/tracking",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "weight",
+      "dimensions",
+      "pickup_point",
+      "pickup_code",
+      "recipient_address"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "weight",
+      "dimensions",
+      "pickup_point"
+    ],
+    "discarded": [
+      "pickup_code",
+      "recipient_address"
+    ],
+    "unavailable": [
+      "sender_name",
+      "receiver_name"
+    ]
+  },
+  "links": [
+    {
+      "domains": [
+        "posti.fi"
+      ],
+      "path": "^/(?:[a-z]{2}/)?tracking/([^/?#]+)(?:/[0-9]+)?/?$"
+    }
+  ],
+  "detection": []
+}

package/dist/carriers/posti/numbers.json

@@ -0,0 +1,52 @@
+{
+  "carrier": "posti",
+  "records": [
+    {
+      "number": "00264300487130023858",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/ItellaPlugins/itella-shipping-woocommerce/issues/224",
+        "date": "2026-09-03"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "postnord",
+          "usps",
+          "nz-post",
+          "poczta-polska"
+        ]
+      },
+      "note": "Example Posti tracking link quoted in an open-source plugin's issue, not a confirmed shipment. The source attributes it to Posti, which no rule claims."
+    },
+    {
+      "number": "LR288565359NL",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/hatlabs/posti-cli"
+      },
+      "expect": {
+        "carrier": "spring-gds",
+        "confidence": "high"
+      },
+      "note": "Published open-source tracking example. Posti returned history in a local live check on 2026-09-21 and in the canary until 2026-09-24; since 2026-09-25 it is past Posti's retention (zero hits, and Posti's tracker reports it as not found). Issuer-based number detection still selects PostNL."
+    },
+    {
+      "number": "LV679342632US",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6807896d85762edcd5ff538f",
+        "date": "2025-04-22"
+      },
+      "expect": {
+        "carrier": "intl-post",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. The source attributes it to Posti; detection selects the generic postal carrier. US item inbound to Finland."
+    }
+  ]
+}

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

@@ -0,0 +1,4 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function postiStatus(main: string, subStatus: string[]): ClassifiedStatus | undefined;
+/** Map each scan's own label, never the current parcel state or explanatory reason text. */
+export declare function postiEventStage(description: string): string;

package/dist/carriers/posti/status.js

@@ -0,0 +1,41 @@
+// ConsumerShipmentStatusMain in Posti's public parcels bundle, inspected
+// 2026-09-21. Return movement is not a completed return.
+const MAIN = {
+    ORDER_RECEIVED: { status: 'pending', stage: 'registered' },
+    WAITING: { status: 'pending', stage: 'registered' },
+    RECEIVED: { status: 'in_transit', stage: 'accepted' },
+    IN_TRANSPORT: { status: 'in_transit', stage: 'in_transit' },
+    IN_DELIVERY: { status: 'out_for_delivery', stage: 'out_for_delivery' },
+    READY_FOR_PICKUP: { status: 'in_transit', stage: 'ready_for_pickup' },
+    DELIVERED: { status: 'delivered', stage: 'delivered' },
+    RETURN_WAITING: { status: 'in_transit', stage: 'in_transit' },
+    RETURN_IN_TRANSPORT: { status: 'in_transit', stage: 'in_transit' },
+    RETURN_READY_FOR_PICKUP: { status: 'in_transit', stage: 'in_transit' },
+    RETURN_DELIVERED: { status: 'exception', stage: 'returned' },
+};
+export function postiStatus(main, subStatus) {
+    if (main === 'IN_TRANSPORT' && subStatus.some((code) => ['IN_CUSTOMS_PROCESS', 'UNDECLARED'].includes(code))) {
+        return { status: 'in_transit', stage: 'customs' };
+    }
+    return MAIN[main];
+}
+/** Map each scan's own label, never the current parcel state or explanatory reason text. */
+export function postiEventStage(description) {
+    const text = description.trim().toLowerCase();
+    if (/^(?:the )?item has been delivered\.?$/.test(text))
+        return 'delivered';
+    if (/^(?:the )?item is ready for (?:a )?pick ?up\.?$/.test(text))
+        return 'ready_for_pickup';
+    if (/^(?:the )?item is (?:out for|in) delivery\.?$/.test(text))
+        return 'out_for_delivery';
+    if (/^(?:the )?item has been returned to (?:the )?sender\.?$/.test(text))
+        return 'returned';
+    if (/^declare the item|^the item has been declared|^handling fee for item/.test(text))
+        return 'customs';
+    if (/^(?:the )?item (?:is in (?:sorting|transport)|accepted from transport|has been released for delivery|arrived in the destination country|has departed from country of origin)/.test(text))
+        return 'in_transit';
+    if (/^(?:the )?item (?:has been received|has been accepted)/.test(text))
+        return 'accepted';
+    // Notifications, electronic pre-advice and unmapped wording prove no new movement.
+    return 'pending';
+}

package/dist/carriers/posti/statuses.json

@@ -0,0 +1,18 @@
+{
+  "carrier": "posti",
+  "entries": [
+    { "code": "ORDER_RECEIVED", "stage": "registered", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum; no physical acceptance." },
+    { "code": "RECEIVED", "stage": "accepted", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum." },
+    { "code": "IN_TRANSPORT", "stage": "in_transit", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum." },
+    { "code": "IN_DELIVERY", "stage": "out_for_delivery", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum." },
+    { "code": "READY_FOR_PICKUP", "stage": "ready_for_pickup", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum." },
+    { "code": "DELIVERED", "stage": "delivered", "confirmedBy": "live", "firstSeen": "2026-09-21", "note": "Public corpus example and the Posti consumer main enum." },
+    { "code": "RETURN_IN_TRANSPORT", "stage": "in_transit", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Return movement is not terminal." },
+    { "code": "RETURN_DELIVERED", "stage": "returned", "confirmedBy": "source", "firstSeen": "2026-09-21", "note": "Posti public ConsumerShipmentStatusMain enum." },
+    { "wording": "The item has been delivered", "language": "en", "stage": "delivered", "confirmedBy": "live", "firstSeen": "2026-09-21" },
+    { "wording": "Item is ready for a pick up", "language": "en", "stage": "ready_for_pickup", "confirmedBy": "live", "firstSeen": "2026-09-21" },
+    { "wording": "Item accepted from transport", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-09-21" },
+    { "wording": "Item has been released for delivery.", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-09-21" },
+    { "wording": "We sent the recipient an email about the item.", "language": "en", "stage": "pending", "confirmedBy": "live", "firstSeen": "2026-09-21", "note": "Notification alone proves no new movement." }
+  ]
+}

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

@@ -0,0 +1,39 @@
+/**
+ * PostLogistics tracking.
+ *
+ * The public tracker at `tracking.postlogistics.ch` posts the identifier to
+ * `eosapi.postlogistics.ch/api/trackandtrace/public`. The response says what
+ * the identifier was:
+ *
+ * - `Type` 1: a barcode. The answer may contain several shipments, so only the
+ *   one whose `Identifier` equals the requested barcode is read.
+ * - `Type` 2: a customer reference that resolved to one or more barcodes.
+ *   Shippers reuse references, so only the one current consignment among them
+ *   is merged; an answer without one is a not-found (`referenceConsignment`).
+ * - `Type` 3: a Swiss Post parcel barcode PostLogistics does not hold. The
+ *   endpoint relays Swiss Post's own scans (placeholder `PST` codes, no place),
+ *   so the parcel is Swiss Post's: once the echo matches, this is a not-found
+ *   and routing asks the Swiss Post adapter instead.
+ *
+ * Any other type is refused rather than guessed at. A `Data: null` answer is
+ * PostLogistics' explicit "unknown identifier".
+ */
+import type { AdapterFactory, Recognition } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+/** Projects one track-and-trace payload. Pure: the offline tests target this. */
+export declare function parsePostlogisticsTrackingResponse(value: unknown, trackingNumber: string, now?: number): CarrierResult;
+export declare class PostlogisticsTracker {
+    private readonly fetcher;
+    private readonly timeoutMs;
+    private readonly now;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        timeoutMs?: number;
+        now?: () => number;
+    });
+    fetch(trackingNumber: string): Promise<CarrierResult>;
+    recognizes(trackingNumber: string): Promise<Recognition>;
+}
+/** Kept for the host's legacy dispatch chain until it is deleted. */
+export declare function fetchPostlogistics(trackingNumber: string): Promise<CarrierResult>;
+export declare const adapter: AdapterFactory;

package/dist/carriers/postlogistics/adapter.js

@@ -0,0 +1,162 @@
+import { NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { referenceConsignment } from '../swiss-post-cargo/reference.js';
+import { postlogisticsIdentifier } from './number.js';
+import { postlogisticsStatus } from './status.js';
+const PROVIDER = 'PostLogistics';
+const UPSTREAM = 'PostLogistics tracking';
+const TRACK_URL = 'https://eosapi.postlogistics.ch/api/trackandtrace/public?culture=fr-FR';
+const DEFAULT_TIMEOUT_MS = 15_000;
+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, '');
+}
+/** Projects one track-and-trace payload. Pure: the offline tests target this. */
+export function parsePostlogisticsTrackingResponse(value, trackingNumber, now = Date.now()) {
+    const payload = record(value);
+    if (payload.Data === null)
+        throw new NotFoundError(PROVIDER);
+    if (!Array.isArray(payload.Data)) {
+        throw new SchemaError(PROVIDER, 'PostLogistics returned an invalid tracking response');
+    }
+    const items = recordArray(payload.Data);
+    if (items.length !== payload.Data.length) {
+        throw new SchemaError(PROVIDER, 'PostLogistics returned an invalid shipment entry');
+    }
+    if (items.length === 0)
+        throw new SchemaError(PROVIDER, 'PostLogistics did not return a shipment entry');
+    const responseType = Number(payload.Type);
+    if (responseType !== 1 && responseType !== 2 && responseType !== 3) {
+        throw new SchemaError(PROVIDER, 'PostLogistics returned an invalid tracking response type');
+    }
+    const identified = items.filter((candidate) => comparableIdentifier(candidate.Identifier));
+    if (identified.length === 0) {
+        throw new SchemaError(PROVIDER, 'PostLogistics did not return a shipment identifier');
+    }
+    let shipments = identified;
+    if (responseType !== 2) {
+        const requested = comparableIdentifier(trackingNumber);
+        shipments = identified.filter((candidate) => comparableIdentifier(candidate.Identifier) === requested);
+        if (shipments.length === 0) {
+            throw new SchemaError(PROVIDER, 'PostLogistics returned a different shipment');
+        }
+    }
+    if (responseType === 3) {
+        throw new NotFoundError(PROVIDER, 'PostLogistics only relays Swiss Post tracking for this barcode');
+    }
+    if (responseType === 2) {
+        shipments = referenceConsignment(shipments, (shipment) => recordArray(shipment.History)
+            .map((event) => Date.parse(text(event.TimeStamp))), PROVIDER, now);
+    }
+    const history = shipments.flatMap((shipment) => recordArray(shipment.History));
+    // Merged references interleave several barcodes, so order by absolute
+    // instant and keep the provider's order for entries that share one.
+    const orderedHistory = history.map((event, index) => {
+        const rawTimestamp = text(event.TimeStamp);
+        const parsedTimestamp = Date.parse(rawTimestamp);
+        return {
+            event,
+            index,
+            timestamp: Number.isFinite(parsedTimestamp) ? parsedTimestamp : Number.NEGATIVE_INFINITY,
+        };
+    }).sort((left, right) => right.timestamp - left.timestamp || left.index - right.index);
+    const events = orderedHistory.map(({ event }) => ({
+        time: text(event.TimeStamp),
+        location: text(event.City),
+        description: text(event.Description),
+    }));
+    const latest = orderedHistory[0]?.event ?? {};
+    const latestStatus = text(latest.Status);
+    const eta = shipments.map((shipment) => record(shipment.DriveAndArrive))
+        .map((drive) => text(drive.PlannedDeliveryDate) || text(drive.EstimatedArrival))
+        .find(Boolean) ?? '';
+    return {
+        status: postlogisticsStatus(latestStatus),
+        last_status_text: text(latest.Description) || latestStatus,
+        last_update: text(latest.TimeStamp) || null,
+        expected_delivery: eta ? eta.slice(0, 10) : null,
+        events,
+    };
+}
+export class PostlogisticsTracker {
+    fetcher;
+    timeoutMs;
+    now;
+    constructor(options = {}) {
+        this.fetcher = options.fetcher;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.now = options.now ?? Date.now;
+    }
+    async fetch(trackingNumber) {
+        const dashed = postlogisticsIdentifier(trackingNumber);
+        const identifiers = dashed === trackingNumber ? [trackingNumber] : [trackingNumber, dashed];
+        const signal = AbortSignal.timeout(this.timeoutMs);
+        for (const [index, identifier] of identifiers.entries()) {
+            const { bytes } = await fetchBounded(TRACK_URL, {
+                method: 'POST',
+                headers: {
+                    ...BASE_HEADERS,
+                    'Content-Type': 'application/json',
+                    Origin: 'https://tracking.postlogistics.ch',
+                    Referer: 'https://tracking.postlogistics.ch/',
+                },
+                body: JSON.stringify({ Identifier: identifier }),
+                signal,
+            }, { provider: UPSTREAM, timeoutMs: this.timeoutMs, fetcher: this.fetcher });
+            try {
+                return parsePostlogisticsTrackingResponse(parseJsonBytes(bytes, UPSTREAM), trackingNumber, this.now());
+            }
+            catch (error) {
+                if (!(error instanceof NotFoundError) || index === identifiers.length - 1)
+                    throw error;
+            }
+        }
+        throw new NotFoundError(PROVIDER);
+    }
+    async recognizes(trackingNumber) {
+        try {
+            const result = await this.fetch(trackingNumber);
+            const events = (result.events ?? []).filter((event) => event.description && event.time);
+            const times = events.map((event) => explicitOffsetTime(event.time)?.timestamp)
+                .filter((value) => value !== undefined);
+            return {
+                known: events.length > 0,
+                lastActivityAt: times.length ? new Date(Math.max(...times)).toISOString() : null,
+            };
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return { known: false };
+            throw error;
+        }
+    }
+}
+/** Kept for the host's legacy dispatch chain until it is deleted. */
+export async function fetchPostlogistics(trackingNumber) {
+    return new PostlogisticsTracker().fetch(trackingNumber);
+}
+export const adapter = (environment) => {
+    const tracker = new PostlogisticsTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'postlogistics',
+        // Keyless POST, with one alternate spelling after a compact not-found.
+        steps: ['direct'],
+        track: (input) => tracker.fetch(input.number),
+        recognize: (number) => tracker.recognizes(number),
+    };
+};

package/dist/carriers/postlogistics/carrier.json

@@ -0,0 +1,67 @@
+{
+  "id": "postlogistics",
+  "displayName": "PostLogistics",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "CH"
+    ]
+  },
+  "brand": {
+    "color": "#ffcc00"
+  },
+  "selectable": true,
+  "timezone": "Europe/Zurich",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "postlogistics",
+    "steps": [
+      "direct"
+    ],
+    "recognition": {
+      "rank": 26
+    }
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "eta"
+  ],
+  "portal": {
+    "url": "https://tracking.postlogistics.ch/public/trackandtrace/{trackingNumber}",
+    "canaryUrl": "https://tracking.postlogistics.ch/public/trackandtrace",
+    "shows": [
+      "status",
+      "history",
+      "eta"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "eta"
+    ],
+    "discarded": [],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "tracking.postlogistics.ch"
+      ],
+      "path": "^/public/trackandtrace/([^/?#]+)/?$"
+    }
+  ],
+  "detection": [
+    {
+      "id": "postlogistics-dashed-reference",
+      "pattern": "^\\d{11}$",
+      "rawPattern": "^\\d{8}-\\d{3}$",
+      "confidence": "high"
+    },
+    {
+      "id": "postlogistics-compact-reference",
+      "pattern": "^\\d{11}$",
+      "confidence": "low"
+    }
+  ]
+}

package/dist/carriers/postlogistics/number.d.ts

@@ -0,0 +1,2 @@
+/** PostLogistics' eight-digit reference and three-digit suffix are separated by a dash. */
+export declare function postlogisticsIdentifier(raw: string): string;

package/dist/carriers/postlogistics/number.js

@@ -0,0 +1,7 @@
+/** PostLogistics' eight-digit reference and three-digit suffix are separated by a dash. */
+export function postlogisticsIdentifier(raw) {
+    const value = raw.trim();
+    return /^\d{11}$/.test(value)
+        ? `${value.slice(0, 8)}-${value.slice(8)}`
+        : value;
+}