universal-parcel-scraper 0.55.0-main.708 → 0.56.0-main.720

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

@@ -51,6 +51,7 @@ export interface DPDParcelShops {
 export interface DPDAppTier {
     /**
      * `leads` when the guest tier is still to come and needs time left. `postcode` is empty when none was given.
+     * `waiting`, given to a leading tier, is called when the lookup starts waiting for the tier's session to open.
      * `stop` aborts when the lookup has its answer without the tier, which then reads nothing more.
      */
     run(number: string, context: {
@@ -59,11 +60,10 @@ export interface DPDAppTier {
         timeoutMs: number;
         leads: boolean;
         postcode: string;
+        waiting?: () => void;
     }): Promise<CarrierResult>;
     /** The failures of either tier the other may answer after. */
     recovers(error: unknown): boolean;
-    /** Whether a lookup would first wait for the tier's session to open. */
-    opening?(): boolean;
 }
 export declare class DPDTracker {
     #private;

package/dist/carriers/dpd/adapter.js

@@ -632,35 +632,44 @@ export class DPDTracker {
         let guest;
         const guestReply = () => guest ??= this.apiFetch(trackingNumber, resolvedPostcode, lookup);
         /**
-         * While the app's session opens, the guest tier is asked beside it. A parcel
-         * the guest tier does not know, or places in another country, the app does
-         * not answer either: the app stops waiting, reads nothing once its session
-         * opens, and the guest tier's step reports it. Otherwise the app keeps
-         * waiting, and the reply serves the guest tier's step if the session does
-         * not open in time. A failed reply is asked again there.
+         * While the app's session opens, the guest tier is asked beside it, not
+         * while a host's store gives back a saved session. A parcel the guest tier
+         * does not know, or places in another country, the app does not answer
+         * either: the app stops waiting, reads nothing once its session opens, and
+         * the guest tier's step reports it. Otherwise the app keeps waiting, because
+         * the guest tier's reply without a postcode is a summary: one entry per
+         * milestone, without places, registration, repeated delivery attempts and
+         * failures, or the parcel's size. Its clocks and wording also differ from
+         * the app's scans, so a consumer that stored it would keep both versions of
+         * a scan once a later lookup reads the app. The reply serves the guest
+         * tier's step if the session does not open in time. A failed reply is
+         * asked again there.
          */
-        const besideGuest = (tracked, stop) => {
+        const besideGuest = (stop) => {
             const reply = guestReply();
             const pending = new Promise(() => { });
-            return Promise.race([tracked, reply.then(() => pending, (error) => {
-                    if (!app.recovers(error)) {
-                        const stopped = new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', { reason: DPD_DE_SESSION_OPENING });
-                        stop.abort(stopped);
-                        throw stopped;
-                    }
-                    if (guest === reply)
-                        guest = undefined;
-                    return pending;
-                })]);
+            return reply.then(() => pending, (error) => {
+                if (!app.recovers(error)) {
+                    const stopped = new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', { reason: DPD_DE_SESSION_OPENING });
+                    stop.abort(stopped);
+                    throw stopped;
+                }
+                if (guest === reply)
+                    guest = undefined;
+                return pending;
+            });
         };
         const appStep = (leads) => ({
             id: 'app',
             ...(leads ? {} : { recovers: appRecovers }),
             run: ({ signal, remainingMs }) => {
-                const opening = leads && app.opening?.() === true;
                 const stop = new AbortController();
-                const tracked = app.run(trackingNumber, { signal, stop: stop.signal, timeoutMs: remainingMs, leads, postcode: resolvedPostcode });
-                return opening ? besideGuest(tracked, stop) : tracked;
+                const tier = { signal, stop: stop.signal, timeoutMs: remainingMs, leads, postcode: resolvedPostcode };
+                if (!leads)
+                    return app.run(trackingNumber, tier);
+                let waiting;
+                const opening = new Promise((resolve) => { waiting = resolve; });
+                return Promise.race([app.run(trackingNumber, { ...tier, waiting }), opening.then(() => besideGuest(stop))]);
             },
         });
         const result = await runSteps({

package/dist/carriers/dpd-de/adapter.js

@@ -16,15 +16,14 @@ export const adapter = (environment) => {
         recorder: environment.recorder,
         userAgent: environment.userAgent,
         app: {
-            run: (number, { signal, stop, timeoutMs, leads, postcode }) => app.track(number, {
-                signal, stop, timeoutMs, postcode, sessionWaitMs: leads ? Math.max(0, timeoutMs - GUEST_RESERVE_MS) : timeoutMs,
+            run: (number, { signal, stop, timeoutMs, leads, postcode, waiting }) => app.track(number, {
+                signal, stop, timeoutMs, postcode, waiting, sessionWaitMs: leads ? Math.max(0, timeoutMs - GUEST_RESERVE_MS) : timeoutMs,
             }),
             // Each service has its own host, limits and outages, so either answers when
             // the other fails. Both read the same parcel: neither can place another
             // country's delivery in Germany, nor find a parcel the guest API does not know.
             recovers: error => carrierErrorKind(error) !== 'not_found'
                 && !(error instanceof CarrierError && error.reason === DPD_DE_OTHER_COUNTRY),
-            opening: () => service.opening,
         },
     });
     return {

package/dist/carriers/dpd-de/app.d.ts

@@ -25,8 +25,10 @@ export declare class DpdDeAppClient {
         now?: () => number;
     });
     /**
-     * `sessionWaitMs` bounds the wait for a session still opening; the whole `timeoutMs` by default.
-     * Once `stop` aborts, the lookup ends with its reason when the session opens, and reads nothing.
+     * `sessionWaitMs` is how long from its start the lookup may wait for a session still opening, also
+     * for one that replaces a session the service refused; the whole `timeoutMs` by default. `waiting`
+     * is called when the lookup starts waiting for one. Once `stop` aborts, the lookup stops waiting,
+     * ends with its reason and reads nothing.
      * DPD checks a `postcode` against the recipient's: a rejected one gets one lookup without it, and
      * the result says which, as on the guest API.
      */
@@ -36,5 +38,6 @@ export declare class DpdDeAppClient {
         sessionWaitMs?: number;
         postcode?: string;
         stop?: AbortSignal;
+        waiting?: () => void;
     }): Promise<CarrierResult>;
 }

package/dist/carriers/dpd-de/app.js

@@ -195,8 +195,10 @@ export class DpdDeAppClient {
         this.#service = options.service ?? new DpdAppService(options);
     }
     /**
-     * `sessionWaitMs` bounds the wait for a session still opening; the whole `timeoutMs` by default.
-     * Once `stop` aborts, the lookup ends with its reason when the session opens, and reads nothing.
+     * `sessionWaitMs` is how long from its start the lookup may wait for a session still opening, also
+     * for one that replaces a session the service refused; the whole `timeoutMs` by default. `waiting`
+     * is called when the lookup starts waiting for one. Once `stop` aborts, the lookup stops waiting,
+     * ends with its reason and reads nothing.
      * DPD checks a `postcode` against the recipient's: a rejected one gets one lookup without it, and
      * the result says which, as on the guest API.
      */
@@ -208,9 +210,12 @@ export class DpdDeAppClient {
             throw new TypeError('DPD Germany app tracking takes a 5-digit postcode');
         const deadline = performance.now() + options.timeoutMs;
         const left = () => Math.max(1, Math.floor(deadline - performance.now()));
+        const waitEnds = Math.min(deadline, performance.now() + (options.sessionWaitMs ?? Infinity));
         try {
             for (let attempt = 0;; attempt += 1) {
-                const session = await this.#service.session(options.signal, Math.min(left(), options.sessionWaitMs ?? Infinity));
+                const session = await this.#service.session(options.signal, Math.max(0, waitEnds - performance.now()), {
+                    waiting: options.waiting, stop: options.stop,
+                });
                 options.stop?.throwIfAborted();
                 // Read-only: the parcel is neither added to the session nor redirected.
                 const tracking = (zip) => this.#service.call('getTrackingData', { SessionToken: session, ParcelNo: number, DeliveryZipCode: zip,
@@ -230,11 +235,13 @@ export class DpdDeAppClient {
                         data = await tracking('');
                         verified = false;
                     }
+                    options.stop?.throwIfAborted();
                     const scans = await this.#service.call('getTrackingScanList', { SessionToken: session, ParcelNo: number,
                         DeliveryZipCode: verified ? postcode : '' }, options.signal, left());
                     const { result, shop } = parseDpdDeApp(data, scans, number);
                     // The scans name the shop without its address, which the shop's own record adds.
                     // Without it, the parcel is found all the same and its pickup point keeps the name alone.
+                    options.stop?.throwIfAborted();
                     const address = shop ? (await this.#service.parcelShop(shop, { signal: options.signal, timeoutMs: left() }))?.address : undefined;
                     if (address)
                         result.pickup_point = `${result.pickup_point}\n${address}`;

package/dist/carriers/dpd-de/carrier.json

@@ -84,7 +84,7 @@
       "domains": [
         "tracking.dpd.de"
       ],
-      "path": "^/status/[a-z]{2}_[A-Z]{2}/parcel/(\\d{14})/?$"
+      "path": "^/status/[a-z]{2}_[A-Z]{2}/parcel/(\\d{14}[0-9A-Z]?)/?$"
     },
     {
       "domains": [

package/dist/carriers/dpd-de/numbers.json

@@ -296,6 +296,32 @@
         ]
       },
       "note": "Parcel number with its printed check character, from the German consumer forum. DPD Germany's tracking returns the fourteen-digit parcel's history."
+    },
+    {
+      "number": "13499302309359E",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20220128062637/https://tracking.dpd.de/status/de_DE/parcel/13499302309359E",
+        "date": "2022-01-28",
+        "access": "indexed_excerpt",
+        "dateKind": "capture"
+      },
+      "context": {
+        "assessment": "candidate"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dpd-pl",
+          "dpd",
+          "chronopost",
+          "dpd-de",
+          "dpd-uk"
+        ]
+      },
+      "note": "Printed with its check character. Its 13 depot range is the one DPD Poland's own archived tracking pages show. Neither DPD Germany nor DPD Poland found it in October 2026."
     }
   ]
 }

package/dist/carriers/dpd-de/service.d.ts

@@ -69,7 +69,7 @@ export declare class DpdAppService {
         signal: AbortSignal;
         timeoutMs: number;
     }): Promise<DpdParcelShop | undefined>;
-    /** Whether a lookup would wait for a session to open: none is open. */
+    /** Whether no session is open, as while one opens or a host's store gives back its sessions. */
     get opening(): boolean;
     /** Forgets a session the service refused, unless another lookup already replaced it. */
     expire(session: string): void;
@@ -84,9 +84,14 @@ export declare class DpdAppService {
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
-     * A session past its renewal age answers at once while the next one opens.
+     * A session past its renewal age answers at once while the next one opens. `waiting` is called
+     * when the lookup starts waiting for an opening, once a host's store has given back its sessions.
+     * A lookup whose `stop` aborts stops waiting with its reason, and still holds the opening.
      */
-    session(signal: AbortSignal, waitMs: number): Promise<string>;
+    session(signal: AbortSignal, waitMs: number, options?: {
+        waiting?: () => void;
+        stop?: AbortSignal;
+    }): Promise<string>;
     call(operation: string, fields: Fields, signal: AbortSignal, timeoutMs: number): Promise<XmlNode>;
 }
 /**

package/dist/carriers/dpd-de/service.js

@@ -150,7 +150,7 @@ export class DpdAppService {
             return undefined;
         }
     }
-    /** Whether a lookup would wait for a session to open: none is open. */
+    /** Whether no session is open, as while one opens or a host's store gives back its sessions. */
     get opening() {
         return this.#session === null;
     }
@@ -321,9 +321,11 @@ export class DpdAppService {
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
-     * A session past its renewal age answers at once while the next one opens.
+     * A session past its renewal age answers at once while the next one opens. `waiting` is called
+     * when the lookup starts waiting for an opening, once a host's store has given back its sessions.
+     * A lookup whose `stop` aborts stops waiting with its reason, and still holds the opening.
      */
-    async session(signal, waitMs) {
+    async session(signal, waitMs, options = {}) {
         if (this.#loading)
             await until(this.#loading, signal);
         const current = this.#session;
@@ -339,21 +341,20 @@ export class DpdAppService {
         }
         if (current)
             return current.token;
-        let leave;
+        options.waiting?.();
+        const ended = options.stop ? AbortSignal.any([signal, options.stop]) : signal;
+        ended.throwIfAborted();
         let timer;
-        const left = new Promise((_resolve, reject) => {
-            leave = () => reject(signal.reason);
+        const late = new Promise((_resolve, reject) => {
             timer = setTimeout(() => reject(new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', {
                 reason: DPD_DE_SESSION_OPENING,
             })), Math.max(0, Math.min(waitMs, SESSION_OPEN_MS)));
         });
-        signal.addEventListener('abort', leave, { once: true });
         try {
-            return await Promise.race([token, left]);
+            return await until(Promise.race([token, late]), ended);
         }
         finally {
             clearTimeout(timer);
-            signal.removeEventListener('abort', leave);
         }
     }
     async call(operation, fields, signal, timeoutMs) {

package/dist/carriers/dpd-pl/carrier.json

@@ -84,6 +84,13 @@
       "pattern": "^13\\d{12}$",
       "confidence": "low",
       "preferred": true
+    },
+    {
+      "id": "dpd-pl-3",
+      "pattern": "^13\\d{12}[0-9A-Z]$",
+      "confidence": "low",
+      "checksum": "dpd",
+      "preferred": true
     }
   ]
 }

package/dist/carriers/emile/carrier.json

@@ -0,0 +1,56 @@
+{
+  "id": "emile",
+  "displayName": "Emile",
+  "aliases": [
+    "Emile Express"
+  ],
+  "region": {
+    "countries": [
+      "CA"
+    ]
+  },
+  "brand": {
+    "color": "#e42920"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "link-only",
+    "adapter": null,
+    "steps": []
+  },
+  "capabilities": [],
+  "portal": {
+    "url": "https://www.emileps.com/tracking?tracking={trackingNumber}",
+    "searchUrl": "https://www.emileps.com/tracking",
+    "canaryUrl": "https://www.emileps.com/",
+    "shows": [
+      "status",
+      "history",
+      "delivery_photo"
+    ],
+    "scraped": [],
+    "discarded": [],
+    "unavailable": [
+      "status",
+      "history"
+    ]
+  },
+  "links": [
+    {
+      "domains": [
+        "emileps.com"
+      ],
+      "params": [
+        "tracking"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "emile-1",
+      "pattern": "^EM\\d{12}CA$",
+      "confidence": "low"
+    }
+  ]
+}

package/dist/carriers/emile/numbers.json

@@ -0,0 +1,94 @@
+{
+  "carrier": "emile",
+  "records": [
+    {
+      "number": "EM200006549049CA",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20260102183550/https://track.4px.com/query/EM200006549049CA",
+        "date": "2026-01-02",
+        "dateKind": "capture",
+        "access": "indexed_excerpt"
+      },
+      "context": {
+        "assessment": "candidate"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "emile"
+        ]
+      },
+      "note": "A lookup on 4PX's tracker archived by the Wayback Machine. 4PX's feed returns the parcel's history and names Emile as its last-mile provider."
+    },
+    {
+      "number": "EM100048497916CA",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20250306075727/https://global.cainiao.com/global/detail.json?mailNos=EM100048497916CA&lang=en-US&language=en-US",
+        "date": "2025-03-06",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "quarantine": true,
+      "context": {
+        "assessment": "review"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "emile"
+        ]
+      },
+      "note": "A lookup on Cainiao's global tracker archived by the Wayback Machine. The archived history of this AliExpress parcel ends with a Canadian local delivery company receiving it, but Cainiao names no company; only the shape points to Emile."
+    },
+    {
+      "number": "EM100047250023CA",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20250217144441/https://www.parcelpanel.com/couriers/emile/",
+        "date": "2025-02-17",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "candidate"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "emile"
+        ]
+      },
+      "note": "The number ParcelPanel's Emile tracking page offered to try, archived by the Wayback Machine. The page rotates its example."
+    },
+    {
+      "number": "EM200009946130CA",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20260410161436/https://www.parcelpanel.com/couriers/emile/",
+        "date": "2026-04-10",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "candidate"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "emile"
+        ]
+      },
+      "note": "The number ParcelPanel's Emile tracking page offered to try, archived by the Wayback Machine. The page rotates its example."
+    }
+  ]
+}

package/dist/carriers/emile/statuses.json

@@ -0,0 +1,4 @@
+{
+  "carrier": "emile",
+  "entries": []
+}

package/dist/carriers/four-px/numbers.json

@@ -216,9 +216,12 @@
       },
       "expect": {
         "carrier": "unknown",
-        "confidence": "none"
+        "confidence": "low",
+        "candidates": [
+          "emile"
+        ]
       },
-      "note": "A lookup on 4PX's tracker archived by the Wayback Machine. The number is the Canadian last-mile courier Emile's, which 4PX's feed also answers; no rule covers it."
+      "note": "A lookup on 4PX's tracker archived by the Wayback Machine. The number is the Canadian last-mile courier Emile's, which 4PX's feed also answers and names as the provider."
     },
     {
       "number": "OJ791502074GB",

package/dist/carriers/gls-ch/status.js

@@ -41,9 +41,9 @@ export function glsSwitzerlandStatus(value) {
 }
 /** Classify a history row that carries no status code, from its wording alone. */
 export function classifyDescription(description) {
-    // EXISTING regression wording: a negative handoff does not prove GLS possession.
+    // GLS knows of the parcel but does not have it yet: no acceptance.
     if (/^(?:the )?parcel has not been handed over to gls[.!]?$/i.test(description.trim())) {
-        return { status: 'unknown', stage: 'in_transit' };
+        return { status: 'pending', stage: 'registered' };
     }
     const translated = trackingLanguageStage(description);
     if (translated)

package/dist/carriers/gls-ch/statuses.json

@@ -16,7 +16,7 @@
     { "code": "CANCELLED", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Both spellings appear." },
     { "code": "FINAL", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "" },
     { "code": "NORECORD", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Reported as status 'unknown'." },
-    { "wording": "The parcel has not been handed over to GLS.", "language": "en", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Deliberately unmapped: a negative handoff does not prove GLS possession. Reported as status 'unknown' with stage in_transit." },
+    { "wording": "The parcel has not been handed over to GLS.", "language": "en", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule, checked before the handover to GLS: GLS knows of the parcel but does not have it." },
     { "wording": "The parcel was handed over to GLS.", "language": "en", "stage": "accepted", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule for rows with no status code." },
     { "wording": "The parcel data was entered into the GLS IT system…", "language": "en", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule; contains 'not yet handed over to GLS' and must not read as a handoff." },
     { "wording": "The parcel was released by customs.", "language": "en", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Release is completion, not active clearance." },

package/dist/carriers/gls-de/statuses.json

@@ -16,7 +16,7 @@
     { "code": "CANCELLED", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Both spellings appear." },
     { "code": "FINAL", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "" },
     { "code": "NORECORD", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-08-30", "note": "Reported as status 'unknown'." },
-    { "wording": "The parcel has not been handed over to GLS.", "language": "en", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Deliberately unmapped: a negative handoff does not prove GLS possession. Reported as status 'unknown' with stage in_transit." },
+    { "wording": "The parcel has not been handed over to GLS.", "language": "en", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule, checked before the handover to GLS: GLS knows of the parcel but does not have it." },
     { "wording": "The parcel was handed over to GLS.", "language": "en", "stage": "accepted", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule for rows with no status code." },
     { "wording": "The parcel data was entered into the GLS IT system…", "language": "en", "stage": "registered", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Wording rule; contains 'not yet handed over to GLS' and must not read as a handoff." },
     { "wording": "The parcel was released by customs.", "language": "en", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-08-30", "note": "Release is completion, not active clearance." },

package/dist/carriers/poczta-polska/parser.js

@@ -17,7 +17,22 @@ export function normalizePocztaPolskaNumber(raw) {
     const sum = [...number].reduce((total, digit, index) => total + Number(digit) * (index % 2 ? 1 : 3), 0);
     return `${number}${(10 - sum % 10) % 10}`;
 }
-function eventClock(value) {
+// Poczta Polska's own offices carry an office type. Scans relayed from partners
+// abroad carry none and keep the sending country's wall clock; an office code
+// alone could be a foreign postcode.
+function polishOffice(office) {
+    return isRecord(office) && clean(office.officeType, 40) !== '';
+}
+// A Polish office dates its scans on Polish time. A wall clock the zone skips
+// or repeats stays local.
+function warsawTime(local) {
+    const parsed = DateTime.fromISO(local, { zone: 'Europe/Warsaw' });
+    if (!parsed.isValid || parsed.toISO({ includeOffset: false, suppressMilliseconds: true }) !== local
+        || parsed.getPossibleOffsets().length !== 1)
+        return null;
+    return parsed.toISO({ suppressMilliseconds: true });
+}
+function eventClock(value, polish) {
     if (value != null && typeof value !== 'string')
         throw new SchemaError('poczta-polska', 'Poczta Polska returned an invalid clock field');
     const raw = clean(value, 64);
@@ -30,6 +45,9 @@ function eventClock(value) {
         // UTC validates the calendar only. It is never attached to local digits.
         const parsed = DateTime.fromISO(raw, { zone: 'UTC' });
         const local = parsed.isValid ? parsed.toISO({ includeOffset: false, suppressMilliseconds: true }) : null;
+        const time = local && polish ? warsawTime(local) : null;
+        if (time)
+            return { time };
         if (local)
             return { local_time: local };
     }
@@ -72,16 +90,14 @@ export function parsePocztaPolska(payload, number) {
         if (startsPocztaPolskaReturn(code, isRecord(raw.state) ? clean(raw.state.code, 16) : ''))
             returning = true;
         const stage = returning && mapped?.stage === 'delivered' ? 'returned' : mapped?.stage;
-        return { ...eventClock(raw.time), description, provider_code: code,
+        return { ...eventClock(raw.time, polishOffice(raw.postOffice)), description, provider_code: code,
             ...(location ? { location } : {}), ...(stage ? { stage } : {}), ...(returning ? { provider_leg: 'return' } : {}) };
     });
     if (!projected.length)
         throw new IndeterminateError('poczta-polska', 'Poczta Polska returned no parcel history');
-    // The widget's last source row is current. Do not compare offsetless wall
-    // clocks from different countries or move malformed clocks behind old scans.
+    // The widget's last source row is current, so the provider's order stands even
+    // when every scan is dated: the clocks never reorder it.
     projected.reverse();
-    if (projected.every(event => event.time))
-        projected.sort((a, b) => Date.parse(b.time) - Date.parse(a.time));
     const seen = new Set();
     const events = projected.filter(event => {
         const key = JSON.stringify(event);

package/dist/carriers/ukrposhta/parser.js

@@ -1,6 +1,7 @@
 import { DateTime } from 'luxon';
 import { isValidS10TrackingNumber } from '../../core/detection/s10.js';
 import { ChallengeError, IndeterminateError, InvalidInputError, SchemaError } from '../../core/errors/index.js';
+import { countryCode } from '../../core/time/index.js';
 import { clean, cleanScalar } from '../../core/transport/text.js';
 import { isRecord } from '../../core/types.js';
 import { ukrposhtaReturnCue, ukrposhtaStatus } from './status.js';
@@ -37,6 +38,19 @@ export function ukrposhtaWallClock(value) {
     const date = DateTime.fromFormat(raw, format, { zone: 'UTC' });
     return date.isValid && date.toFormat(format) === raw ? date.toFormat("yyyy-MM-dd'T'HH:mm:ss") : null;
 }
+/**
+ * A scan in Ukraine is dated on Kyiv time. The minute is the precision both
+ * sources share, so the status API and the portal date one scan alike. A wall
+ * clock the zone skips or repeats stays local.
+ */
+function kyivTime(local) {
+    const minute = `${local.slice(0, 16)}:00`;
+    const parsed = DateTime.fromISO(minute, { zone: 'Europe/Kyiv' });
+    if (!parsed.isValid || parsed.toISO({ includeOffset: false, suppressMilliseconds: true }) !== minute
+        || parsed.getPossibleOffsets().length !== 1)
+        return null;
+    return parsed.toISO({ suppressMilliseconds: true });
+}
 export function parseUkrposhtaOverview(payload, requested) {
     const number = normalizeUkrposhtaNumber(requested);
     const data = envelope(payload);
@@ -64,7 +78,8 @@ export function parseUkrposhtaOverview(payload, requested) {
 function project(rows) {
     const latest = rows[0];
     // Both native histories are current-first. Keep that order across foreign
-    // wall clocks or missing dates instead of sorting them as UTC instants.
+    // wall clocks or missing dates instead of sorting them as instants. A row
+    // naming Ukraine is a Ukrposhta scan; others keep the clock they were given.
     let returnLeg = false;
     const events = new Array(rows.length);
     for (let index = rows.length - 1; index >= 0; index--) {
@@ -77,10 +92,11 @@ function project(rows) {
         if (classified?.stage === 'delivered' && returnLeg)
             classified = { status: 'exception', stage: 'returned' };
         const local = ukrposhtaWallClock(row.date);
+        const time = local && countryCode(row.country) === 'UA' ? kyivTime(local) : null;
         events[index] = {
             description: row.label, provider_code: row.code,
             ...(row.location || row.country ? { location: [row.location, row.country].filter(Boolean).join(', ') } : {}),
-            ...(local ? { local_time: local } : row.date ? { provider_time_text: row.date } : {}),
+            ...(time ? { time } : local ? { local_time: local } : row.date ? { provider_time_text: row.date } : {}),
             ...(classified ? { stage: classified.stage } : {}), ...(returnLeg ? { provider_leg: 'return' } : {}),
         };
     }
@@ -90,7 +106,7 @@ function project(rows) {
     const seen = new Set();
     const deduplicated = events.filter(event => { const key = JSON.stringify(event); if (seen.has(key))
         return false; seen.add(key); return true; });
-    return { status, ...(stage ? { current_stage: stage } : {}), last_status_text: latest.label, last_update: null, events: deduplicated.slice(0, 100) };
+    return { status, ...(stage ? { current_stage: stage } : {}), last_status_text: latest.label, last_update: current.time ?? null, events: deduplicated.slice(0, 100) };
 }
 /**
  * The status-tracking API's reply to one barcode: a bare array of scans, each naming the