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

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/adapter.d.ts

@@ -39,6 +39,10 @@ export declare class GLSSwitzerlandTracker {
      * a 400 or 403 can be a challenge, so it stays a failure.
      */
     recognizes(rawTrackingNumber: string, context?: TrackingContext): Promise<boolean>;
+    /**
+     * A request that fails to reach GLS, or hangs, is sent once more: the first gets at most half of
+     * what is left, so the second fits in the rest.
+     */
     private request;
 }
 /** Keep the verified overview's delivery owner when the postcode detail omits it. */

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

@@ -3,6 +3,7 @@ import { DateTime } from 'luxon';
 import { lookupBudget } from '../../core/adapter/index.js';
 import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
 import { InputRequiredError, InvalidInputError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { withNetworkRetry } from '../../core/runner/networkRetry.js';
 import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { classifyDescription, GLS_STATUSES, statusCode } from './status.js';
@@ -403,17 +404,21 @@ export class GLSSwitzerlandTracker {
             throw error;
         }
     }
+    /**
+     * A request that fails to reach GLS, or hangs, is sent once more: the first gets at most half of
+     * what is left, so the second fits in the rest.
+     */
     async request(url, budget) {
-        const { response, bytes } = await fetchBounded(url, {
+        const { response, bytes } = await withNetworkRetry(budget, (timeoutMs) => fetchBounded(url, {
             signal: budget.signal,
             headers: pageHeaders(this.#userAgent),
         }, {
             provider: 'GLS Switzerland tracking',
-            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
+            timeoutMs: Math.min(this.timeoutMs, timeoutMs),
             maxBytes: MAX_RESPONSE_BYTES,
             allowHttpError: true,
             ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
-        });
+        }));
         if ([400, 403, 404].includes(response.status))
             throw new GLSSwitzerlandTrackingError();
         if (!response.ok)

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/adapter.d.ts

@@ -24,6 +24,10 @@ export declare class GLSGermanyTracker {
      * only after this returns true; a provider failure must stay a failure.
      */
     recognizes(rawTrackingNumber: string, context?: TrackingContext): Promise<boolean>;
+    /**
+     * A request that fails to reach GLS, or hangs, is sent once more: the first gets at most half of
+     * what is left, so the second fits in the rest.
+     */
     private request;
 }
 export declare const adapter: AdapterFactory;

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

@@ -1,5 +1,6 @@
 import { lookupBudget } from '../../core/adapter/index.js';
 import { NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { withNetworkRetry } from '../../core/runner/networkRetry.js';
 import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { glsSwitzerlandDetailApiUrl, glsDeliveryReference, glsSwitzerlandOverviewApiUrl, GLSSwitzerlandTrackingError, normalizeGLSSwitzerlandPostcode, normalizeGLSSwitzerlandTrackingNumber, parseGLSSwitzerlandTrackingResponse, selectGLSParcel, } from '../gls-ch/adapter.js';
@@ -88,17 +89,21 @@ export class GLSGermanyTracker {
             throw error;
         }
     }
+    /**
+     * A request that fails to reach GLS, or hangs, is sent once more: the first gets at most half of
+     * what is left, so the second fits in the rest.
+     */
     async request(url, budget) {
-        const { response, bytes } = await fetchBounded(url, {
+        const { response, bytes } = await withNetworkRetry(budget, (timeoutMs) => fetchBounded(url, {
             signal: budget.signal,
             headers: { Accept: 'application/json', Referer: 'https://gls-group.eu/EU/en/parcel-tracking', 'User-Agent': this.#userAgent },
         }, {
             provider: PROVIDER,
-            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
+            timeoutMs: Math.min(this.timeoutMs, timeoutMs),
             maxBytes: 1_000_000,
             allowHttpError: true,
             ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
-        });
+        }));
         // A challenge, invalid postcode, rate limit or outage must not become "not found".
         if (response.status === 404) {
             const payload = parseJsonBytes(bytes, PROVIDER);

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/gls-fr/adapter.js

@@ -13,6 +13,7 @@ import { DateTime } from 'luxon';
 import { accepted, lookupBudget, recognizeFromLookup } from '../../core/adapter/index.js';
 import { isValidGlsParcelNumber } from '../../core/detection/index.js';
 import { InvalidInputError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { withNetworkRetry } from '../../core/runner/networkRetry.js';
 import { EXPLICIT_OFFSET_PATTERN } from '../../core/time/index.js';
 import { clean, cleanScalar, decodeText, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -280,7 +281,8 @@ export class GLSFranceTracker {
     async fetch(trackingNumber, context = {}, { pickupPoint = true } = {}) {
         const normalized = normalizeGLSFranceTrackingNumber(trackingNumber);
         const printed = printedNumber(trackingNumber);
-        const budget = lookupBudget(context, this.timeoutMs);
+        // Room for a request and its retry.
+        const budget = lookupBudget(context, 2 * this.timeoutMs);
         let parsed;
         try {
             parsed = await this.lookup(normalized, normalized, budget);
@@ -335,16 +337,18 @@ export class GLSFranceTracker {
         };
     }
     async lookup(code, normalized, budget) {
-        const { response, bytes } = await fetchBounded(`${TRACKING_API}/${encodeURIComponent(code)}`, {
+        // A request that fails to reach GLS, or hangs, is sent once more: the first
+        // gets at most half of what is left, so the second fits in the rest.
+        const { response, bytes } = await withNetworkRetry(budget, (timeoutMs) => fetchBounded(`${TRACKING_API}/${encodeURIComponent(code)}`, {
             signal: budget.signal,
             headers: this.#headers(),
         }, {
             provider: 'GLS France tracking',
-            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
+            timeoutMs: Math.min(this.timeoutMs, timeoutMs),
             maxBytes: MAX_RESPONSE_BYTES,
             fetcher: this.#fetcher,
             allowHttpStatuses: [404, 410],
-        });
+        }));
         budget.signal.throwIfAborted();
         if ([404, 410].includes(response.status)) {
             // The native negative names the complete submitted code. An absent API

package/dist/carriers/la-poste/adapter.js

@@ -3,6 +3,7 @@ import { carrierIdFromPartner } from '../../core/catalog/hints.js';
 import { dpdParcelNumber } from '../../core/detection/dpd.js';
 import { CarrierError, InvalidInputError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, isNetworkFailure } from '../../core/runner/networkRetry.js';
 import { isoTime } from '../../core/time/index.js';
 import { clean, decodeText, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -20,6 +21,9 @@ import { eventStage, eventStatus } from './status.js';
 // - Production HTTP 403s carried La Poste's "Site indisponible - Incident en
 //   cours" page and immediately following checks succeeded, so a 403 is
 //   retried up to three times inside the original deadline (see README.md).
+// - A request that hangs would otherwise take the whole budget, so a network
+//   failure or timeout is retried once too, and an attempt gets at most half
+//   of what is left while that retry remains.
 // - The tracking page links the point holding a parcel to La Poste's locator,
 //   `localiser.laposte.fr/{idPoint}`, which redirects to the point's page. That
 //   page carries the point's record, address included, as JSON in
@@ -273,7 +277,7 @@ export class LaPosteTracker {
         const normalized = normalizeLaPosteTrackingNumber(trackingNumber);
         const budgetMs = context.budgetMs ?? this.timeoutMs;
         const deadline = performance.now() + budgetMs;
-        const request = async (remainingMs, signal) => {
+        const request = async (timeoutMs, signal) => {
             const { bytes } = await fetchBounded(laPosteTrackingApiUrl(normalized), {
                 signal,
                 headers: {
@@ -284,7 +288,7 @@ export class LaPosteTracker {
                 },
             }, {
                 provider: 'La Poste tracking',
-                timeoutMs: Math.max(1, Math.floor(Math.min(this.timeoutMs, remainingMs))),
+                timeoutMs: Math.max(1, Math.floor(Math.min(this.timeoutMs, timeoutMs))),
                 maxBytes: MAX_RESPONSE_BYTES,
                 fetcher: this.fetcher,
             });
@@ -302,21 +306,28 @@ export class LaPosteTracker {
         // later, is answered normally. It is a hiccup of that one request, not
         // maintenance, so the page is retried like any other 403: three immediate
         // retries sharing the original deadline. A real incident still fails every
-        // attempt within seconds and reaches the router. Do not retry other HTTP or
-        // parsing failures. Once the deadline is spent the retry is refused, so the
-        // caller still sees the provider's own rejection rather than a budget error.
-        const retriable = (error) => error instanceof UpstreamHttpError
-            && error.status === 403
-            && deadline - performance.now() >= 1;
+        // attempt within seconds and reaches the router. A request that fails to
+        // reach La Poste, or hangs until its timeout, gets one retry as well. Until
+        // that retry is spent, an attempt gets at most half of what is left, so a
+        // hang leaves it time. Do not retry other HTTP or parsing failures, nor a
+        // not-found. Once the deadline is spent the retry is refused, so the caller
+        // still sees the provider's own rejection rather than a budget error.
+        let networkRetried = false;
+        const retriable = (error) => deadline - performance.now() >= 1
+            && ((error instanceof UpstreamHttpError && error.status === 403) || (!networkRetried && isNetworkFailure(error)));
         const retry = {
             id: 'retry',
             recovers: retriable,
-            run: ({ remainingMs, signal }) => request(remainingMs, signal),
+            run: ({ remainingMs, signal, previousError }) => {
+                if (isNetworkFailure(previousError))
+                    networkRetried = true;
+                return request(networkRetried ? remainingMs : firstAttemptMs(remainingMs), signal);
+            },
         };
         return await runSteps({
             carrier: 'la-poste', budgetMs, signal: context.signal, recorder: this.recorder,
         }, [
-            { id: 'direct', run: ({ remainingMs, signal }) => request(remainingMs, signal) },
+            { id: 'direct', run: ({ remainingMs, signal }) => request(firstAttemptMs(remainingMs), signal) },
             retry,
             { ...retry },
             { ...retry },
@@ -369,7 +380,8 @@ export const adapter = (environment) => {
     return {
         id: 'la-poste',
         // One keyless request, then up to three immediate retries of the same
-        // request after a transient HTTP 403, inside the original deadline.
+        // request after a transient HTTP 403, and one after a network failure or
+        // timeout, inside the original deadline.
         steps: ['direct', 'retry'],
         track: (input, context) => tracker.fetch(input.number, context),
         recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeLaPosteTrackingNumber(number))),

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/swiss-post/adapter.d.ts

@@ -21,7 +21,7 @@ export declare function parseSwissPostShipment(item: JsonObject, rawEvents: unkn
 export declare class SwissPostTracker {
     #private;
     constructor(options?: SwissPostOptions);
-    readJson(fetcher: typeof fetch, url: string, init?: RequestInit, budget?: LookupBudget): Promise<unknown>;
+    readJson(fetcher: typeof fetch, url: string, init?: RequestInit, budget?: LookupBudget, timeoutMs?: number): Promise<unknown>;
     /** Cached for the process: the table is large, static, and shared by every lookup. */
     loadTranslations(fetcher: typeof fetch, budget?: LookupBudget): Promise<Record<string, string>>;
     fetch(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;

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

@@ -4,6 +4,7 @@ import { CookieJar } from 'tough-cookie';
 import { lookupBudget } from '../../core/adapter/index.js';
 import { NotFoundError, SchemaError } from '../../core/errors/index.js';
 import { countryCode } from '../../core/time/index.js';
+import { withNetworkRetry } from '../../core/runner/networkRetry.js';
 import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { FALLBACK_EVENT_LABELS, GLOBAL_STATUS_STAGE, STAGE_STATUS, STATUS_MAP, swissPostEventStage, } from './status.js';
@@ -266,14 +267,22 @@ export class SwissPostTracker {
     constructor(options = {}) {
         this.#fetcher = options.fetcher;
     }
-    async readJson(fetcher, url, init = {}, budget) {
+    async readJson(fetcher, url, init = {}, budget, timeoutMs = REQUEST_TIMEOUT_MS) {
         const { bytes } = await fetchBounded(url, budget ? { ...init, signal: budget.signal } : init, {
             provider: 'Swiss Post tracking',
-            timeoutMs: Math.min(REQUEST_TIMEOUT_MS, budget?.remainingMs() ?? REQUEST_TIMEOUT_MS),
+            timeoutMs: Math.min(REQUEST_TIMEOUT_MS, timeoutMs, budget?.remainingMs() ?? REQUEST_TIMEOUT_MS),
             fetcher,
         });
         return parseJsonBytes(bytes, PROVIDER);
     }
+    /**
+     * A call of the lookup's chain, sent once more if it fails to reach Swiss Post or hangs: the
+     * first gets at most half of what is left, so the second fits in the rest. The search's POST
+     * only files the number under the throwaway user, so it is sent again like a read.
+     */
+    #readRetrying(fetcher, url, init, budget) {
+        return withNetworkRetry(budget, (timeoutMs) => this.readJson(fetcher, url, init, budget, timeoutMs));
+    }
     /** Cached for the process: the table is large, static, and shared by every lookup. */
     async loadTranslations(fetcher, budget) {
         if (this.#translations)
@@ -301,11 +310,11 @@ export class SwissPostTracker {
     async fetch(trackingNumber, context = {}) {
         const budget = lookupBudget(context, DEFAULT_BUDGET_MS);
         const fetcher = makeFetchCookie(this.#fetcher ?? fetch, new CookieJar());
-        const userResult = await fetchBounded(`${API_BASE}/user`, { headers: HEADERS, signal: budget.signal }, {
+        const userResult = await withNetworkRetry(budget, (timeoutMs) => fetchBounded(`${API_BASE}/user`, { headers: HEADERS, signal: budget.signal }, {
             provider: 'Swiss Post tracking',
-            timeoutMs: Math.min(REQUEST_TIMEOUT_MS, budget.remainingMs()),
+            timeoutMs: Math.min(REQUEST_TIMEOUT_MS, timeoutMs),
             fetcher,
-        });
+        }));
         const userPayload = parseJsonBytes(userResult.bytes, PROVIDER);
         if (!isRecord(userPayload))
             throw new SchemaError(PROVIDER, 'Swiss Post returned an invalid anonymous user response');
@@ -315,7 +324,7 @@ export class SwissPostTracker {
         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}`, {
+        const historyPayload = await this.#readRetrying(fetcher, `${API_BASE}/history?${query}`, {
             method: 'POST',
             headers: { ...headers, 'Content-Type': 'application/json' },
             body: JSON.stringify({ searchQuery: trackingNumber }),
@@ -323,7 +332,7 @@ export class SwissPostTracker {
         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 }, budget);
+        const items = await this.#readRetrying(fetcher, `${API_BASE}/history/not-included/${encodeURIComponent(hash)}?${query}`, { headers }, budget);
         if (!Array.isArray(items)) {
             throw new SchemaError(PROVIDER, 'Swiss Post returned an invalid shipment response');
         }
@@ -348,7 +357,7 @@ export class SwissPostTracker {
         let events = [];
         if (identity) {
             try {
-                const payload = await this.readJson(fetcher, `${API_BASE}/shipment/id/${encodeURIComponent(identity)}/events`, { headers }, budget);
+                const payload = await this.#readRetrying(fetcher, `${API_BASE}/shipment/id/${encodeURIComponent(identity)}/events`, { headers }, budget);
                 if (Array.isArray(payload))
                     events = payload;
             }

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