universal-parcel-scraper 0.576.0-main.2691 → 0.577.2-main.2708

package/README.md

@@ -155,7 +155,7 @@ createTracker({ providers: ['ParcelsApp', 'Ship24', '17TRACK', 'Postal Ninja', '
 <!-- GENERATED:stages -->
 <img src="docs/assets/stages.svg" alt="DHL: Die Sendung wurde in das Zustellfahrzeug geladen.; Mondial Relay: En cours de livraison; Correios Brazil: Objeto saiu para entrega ao destinatário; Correos Express: EN REPARTO; Yamato Transport: 配達中; La Poste / Colissimo: DISTOU. All are filed under out_for_delivery." width="760">
 
-The carrier folders record 16,184 such statuses, each filed under one stage.
+The carrier folders record 16,187 such statuses, each filed under one stage.
 <!-- /GENERATED:stages -->
 
 Wording nobody recorded yet goes through a classifier that reads seven European languages.

package/data/catalog.json

@@ -3547,6 +3547,9 @@
   "correios-br": {
     "displayName": "Correios Brazil",
     "color": "#ffd500",
+    "aliases": [
+      "Brazil Post"
+    ],
     "countries": [
       "BR"
     ],

package/dist/browser/scraper.js

@@ -3127,6 +3127,7 @@ var Ye = {
 	"correios-br": {
 		displayName: "Correios Brazil",
 		color: "#ffd500",
+		aliases: ["Brazil Post"],
 		countries: ["BR"],
 		selectable: !0,
 		timezone: "UTC",
@@ -29638,6 +29639,7 @@ var tl = /* @__PURE__ */ new Map([
 	["AU", "australia-post"],
 	["BD", "bangladesh-post"],
 	["BG", "bulgarian-posts"],
+	["BR", "correios-br"],
 	["BY", "belpost"],
 	["CA", "canada-post"],
 	["CH", "swiss-post"],

package/dist/carriers/17feia/parser.js

@@ -16,6 +16,12 @@ const WALL_CLOCK = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/;
 const OFFSET = /^[+-]\d{2}:\d{2}$/;
 // 17FEIA's backend keeps the order data on Beijing time; a row kept as a wall clock is read in it only to hold back future ones.
 const HOME_ZONE = 'Asia/Shanghai';
+/**
+ * 17FEIA's steps at its warehouse in China before the flight. The backend
+ * writes them on Beijing time, as it writes the warehouse's receipt; the
+ * offset they carry is the destination line's, whatever the step's clock.
+ */
+const WAREHOUSE_STEPS = new Set(['包裹在去设施路上', '订单待客户确认', '订单已确认', '订单已出库', '出口报关中']);
 // States whose places keep different clocks, so a state does not settle a clock's zone.
 const SPLIT_STATES = new Set(['AK', 'AZ', 'FL', 'ID', 'IN', 'KS', 'KY', 'MI', 'ND', 'NE', 'NV', 'OR', 'SD', 'TN', 'TX']);
 const MAX_ROWS = 500;
@@ -74,14 +80,16 @@ function placedTime(local, label, country, state) {
         return null;
     return { iso: placed.toISO({ suppressMilliseconds: true }), timestamp: placed.toMillis() };
 }
-/** A row's clock: its instant where its place settles one, else its wall clock. */
-function clockOf(stamp, label, country, state) {
+/** A row's clock: its instant where its place or its step at the warehouse settles one, else its wall clock. */
+function clockOf(stamp, step, label, country, state) {
     const wall = WALL_CLOCK.exec(stamp);
     const local = wall ? `${wall[1]}T${wall[2]}` : '';
     const home = local ? firstOccurrence(DateTime.fromISO(local, { zone: HOME_ZONE })) : null;
     // Luxon rolls 24:00:00 over to the next day; only a clock that reads back unchanged is kept.
     if (!home?.isValid || home.toFormat("yyyy-MM-dd'T'HH:mm:ss") !== local)
         throw new SchemaError(PROVIDER, '17FEIA returned an invalid scan time');
+    if (WAREHOUSE_STEPS.has(step))
+        return { time: home.toISO({ suppressMilliseconds: true }), at: home.toMillis() };
     const time = placedTime(local, label, country, state);
     return time ? { time: time.iso, at: time.timestamp } : { local_time: local, at: home.toMillis() };
 }
@@ -95,7 +103,7 @@ function projectRow(row, readAt) {
     const stamp = text(row, 'createTime', 64);
     const country = text(row, 'country', 8).toUpperCase();
     // A US row's state is read only for its clock.
-    const { at, ...clock } = clockOf(stamp, text(row, 'timeZone', 16), country, country === 'US' ? text(row, 'state', 8).toUpperCase() : '');
+    const { at, ...clock } = clockOf(stamp, label, text(row, 'timeZone', 16), country, country === 'US' ? text(row, 'state', 8).toUpperCase() : '');
     // A row dated after the read is not a scan yet.
     if (at > readAt)
         return null;

package/dist/carriers/17feia/status.js

@@ -27,6 +27,8 @@ const LABELS = new Map([
     ['清关行提货到仓', 'customs'],
     ['清关中', 'customs'],
     ['清关完成', 'in_transit'],
+    // Handed in at the partner's depot, before the partner's own first scan.
+    ['已交仓，等待上网', 'in_transit'],
     ['成功签收', 'delivered'],
 ]);
 /** The label on rows relayed from the delivering partner: their wording is the partner's. */

package/dist/carriers/17feia/statuses.json

@@ -18,6 +18,7 @@
     {"code": "清关行提货到仓", "wording": "Broker picked up Shipment and delivered to warehouse.", "stage": "customs", "language": "en", "confirmedBy": "live", "note": "The customs broker takes the shipment to its warehouse for clearance; the shared rules would read a delivery."},
     {"code": "清关中", "wording": "Customs Clearance is in progress.", "stage": "customs", "language": "en", "confirmedBy": "live"},
     {"code": "清关完成", "wording": "Customs Clearance Completed.", "stage": "in_transit", "language": "en", "confirmedBy": "live"},
+    {"code": "已交仓，等待上网", "wording": "Arrived at delivery hub，Awaiting carrie scan.", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "After the clearance, before the delivering partner's first scan: the parcel was handed in at the partner's depot and waits to enter its system."},
     {"code": "运输途中", "wording": "The international shipment has been processed in the parcel center of origin", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Relayed from DHL in Germany, with DHL's place, country and offset. The label marks every relayed row; the stage comes from the partner's wording."},
     {"code": "运输途中", "wording": "The international shipment has been processed in the export parcel center", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Relayed from DHL in Germany."},
     {"code": "运输途中", "wording": "The shipment will be transported to the destination country/destination area and, from there, handed over to the delivery organization.", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Relayed from DHL in Germany, for a parcel bound for France."},

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

@@ -21,6 +21,11 @@
  */
 import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
+/**
+ * The carriers a `detail.json` payload names for the number asked, in lower
+ * case: the destination carrier and each scan's carrier.
+ */
+export declare function cainiaoCarrierNames(value: unknown, trackingNumber: string): ReadonlySet<string>;
 /** Projects one `detail.json` payload. Pure: the offline tests target this. */
 export declare function parseCainiaoTrackingResponse(value: unknown, trackingNumber: string): CarrierResult;
 export declare class CainiaoTracker {
@@ -33,7 +38,13 @@ export declare class CainiaoTracker {
         userAgent?: string;
     });
     fetch(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;
+    /**
+     * The global feed's `detail.json` reply for a number, unparsed, for a
+     * carrier that reads Cainiao's leg of its own parcels.
+     */
+    detail(trackingNumber: string, context?: TrackingContext): Promise<unknown>;
     private read;
+    private payload;
 }
 /** Kept for the host's legacy dispatch chain until it is deleted. */
 export declare function fetchCainiao(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;

package/dist/carriers/aliexpress/adapter.js

@@ -165,8 +165,8 @@ function recordedInBeijing(scan, wall) {
     const beijing = new Date(epoch + BEIJING_OFFSET_MS);
     return Number.isFinite(beijing.getTime()) && beijing.toISOString().slice(0, 19).replace('T', ' ') === wall;
 }
-/** Projects one `detail.json` payload. Pure: the offline tests target this. */
-export function parseCainiaoTrackingResponse(value, trackingNumber) {
+/** The module of a `detail.json` payload for the number asked; any other shipment is refused. */
+function trackingModuleOf(value, trackingNumber) {
     const payload = record(value);
     const rawModules = Array.isArray(payload.module)
         ? payload.module
@@ -186,6 +186,20 @@ export function parseCainiaoTrackingResponse(value, trackingNumber) {
     const trackingModule = identified.find((module) => comparableIdentifier(module.mailNo) === requested);
     if (!trackingModule)
         throw new SchemaError(PROVIDER, 'Cainiao returned a different shipment');
+    return trackingModule;
+}
+/**
+ * The carriers a `detail.json` payload names for the number asked, in lower
+ * case: the destination carrier and each scan's carrier.
+ */
+export function cainiaoCarrierNames(value, trackingNumber) {
+    const trackingModule = trackingModuleOf(value, trackingNumber);
+    return carrierNames(trackingModule, recordArray(trackingModule.detailList));
+}
+/** Projects one `detail.json` payload. Pure: the offline tests target this. */
+export function parseCainiaoTrackingResponse(value, trackingNumber) {
+    const trackingModule = trackingModuleOf(value, trackingNumber);
+    const requested = comparableIdentifier(trackingNumber);
     const rawStatus = text(trackingModule.status);
     const latest = record(trackingModule.latestTrace ?? trackingModule.globalCombinedLogisticsTraceDTO);
     const rawDetails = trackingModule.detailList;
@@ -278,7 +292,7 @@ export class CainiaoTracker {
         const budget = lookupBudget(context, this.timeoutMs);
         try {
             // The feed refuses a request another site refers ("uri is null or empty").
-            return await this.read(`${DETAIL_URL}?${new URLSearchParams({ mailNos: trackingNumber, lang: 'en-US' })}`, DETAIL_PAGE, trackingNumber, budget);
+            return parseCainiaoTrackingResponse(await this.payload(`${DETAIL_URL}?${new URLSearchParams({ mailNos: trackingNumber, lang: 'en-US' })}`, DETAIL_PAGE, budget), trackingNumber);
         }
         catch (error) {
             if (!(error instanceof NotFoundError) || !HOME_DELIVERY.test(comparableIdentifier(trackingNumber)))
@@ -293,11 +307,21 @@ export class CainiaoTracker {
             throw new IndeterminateError(PROVIDER, 'Cainiao has no record of the shipment yet', { reason: 'portal_not_found' });
         }
     }
+    /**
+     * The global feed's `detail.json` reply for a number, unparsed, for a
+     * carrier that reads Cainiao's leg of its own parcels.
+     */
+    async detail(trackingNumber, context = {}) {
+        return this.payload(`${DETAIL_URL}?${new URLSearchParams({ mailNos: trackingNumber, lang: 'en-US' })}`, DETAIL_PAGE, lookupBudget(context, this.timeoutMs));
+    }
     async read(url, referer, trackingNumber, budget) {
+        return parseCainiaoTrackingResponse(await this.payload(url, referer, budget), trackingNumber);
+    }
+    async payload(url, referer, budget) {
         const { bytes } = await fetchBounded(url, { signal: budget.signal, headers: { ...BASE_HEADERS, 'User-Agent': this.userAgent, Referer: referer } }, { provider: UPSTREAM, timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()), fetcher: this.fetcher });
         if (sliderPage(decodeText(bytes)))
             throw new ChallengeError(PROVIDER);
-        return parseCainiaoTrackingResponse(parseJsonBytes(bytes, UPSTREAM), trackingNumber);
+        return parseJsonBytes(bytes, UPSTREAM);
     }
 }
 /** Kept for the host's legacy dispatch chain until it is deleted. */

package/dist/carriers/chunghwa-post/parser.js

@@ -2,10 +2,12 @@ import { DateTime } from 'luxon';
 import { normalizeTrackingNumber } from '../../core/detection/index.js';
 import { ChallengeError, IndeterminateError, InvalidInputError, NoHistoryError, NotFoundError, RateLimitedError, SchemaError } from '../../core/errors/index.js';
 import { languageStageStatus } from '../../core/status/index.js';
+import { firstOccurrence } from '../../core/time/index.js';
 import { clean } from '../../core/transport/text.js';
 import { isRecord } from '../../core/types.js';
 import { chunghwaPostStage } from './status.js';
 export const PROVIDER = 'Chunghwa Post';
+const TAIWAN = 'Asia/Taipei';
 export const isSupportedChunghwaPostNumber = (number) => /^(?:[CELR][A-Z]\d{9}[A-Z]{2}|UH\d{9}TW)$/.test(number);
 export function normalizeChunghwaPostNumber(raw) {
     const number = raw.length <= 64 ? normalizeTrackingNumber(raw) : '';
@@ -32,6 +34,21 @@ function clock(value) {
     }
     throw new SchemaError(PROVIDER, 'Chunghwa Post returned an invalid scan clock');
 }
+/**
+ * Whether Chunghwa Post's own branch made the scan. The official client reads a
+ * branch code of digits or a `TW` office of exchange as one of its own
+ * branches, and links another post's site for a scan made abroad.
+ */
+function ownBranch(row) {
+    const branch = typeof row.BRHNO === 'string' ? row.BRHNO.trim().slice(0, 6) : '';
+    const abroad = row.POST_URL != null && (typeof row.POST_URL !== 'string' || row.POST_URL.trim() !== '');
+    return /^(?:\d{6}|TW[A-Z]{4})$/.test(branch) && !abroad;
+}
+/** A wall clock of Chunghwa Post's own branch: Taiwan keeps one zone, without daylight saving. */
+function taiwanInstant(wall) {
+    const placed = firstOccurrence(DateTime.fromISO(wall, { zone: TAIWAN }));
+    return placed.isValid ? placed.toUTC().toISO({ suppressMilliseconds: true }) ?? undefined : undefined;
+}
 export function parseChunghwaPost(payload, raw) {
     const number = normalizeChunghwaPostNumber(raw);
     if (!Array.isArray(payload) || !payload.length || payload.length > 4)
@@ -83,14 +100,17 @@ export function parseChunghwaPost(payload, raw) {
             throw new SchemaError(PROVIDER, 'Chunghwa Post returned an invalid scan status');
         const classified = chunghwaPostStage(description);
         const location = text(row, 'BRHNAT', 100);
-        return { local_time: clock(row.DATIME), description, provider_code: code, ...(location ? { location } : {}),
+        const localTime = clock(row.DATIME);
+        // A scan abroad is on that country's local clock, as the tracker's notes say, so it keeps its wall clock.
+        const time = ownBranch(row) ? taiwanInstant(localTime) : undefined;
+        return { ...(time ? { time } : {}), local_time: localTime, description, provider_code: code, ...(location ? { location } : {}),
             ...(classified ? { stage: classified.stage, stage_source: classified.source } : {}) };
     });
     const newest = events[0];
     const classified = chunghwaPostStage(newest.description);
     return { status: classified ? languageStageStatus(classified.stage) : 'unknown',
         ...(classified ? { current_stage: classified.stage, current_stage_source: classified.source } : {}),
-        provider_code: newest.provider_code, last_status_text: newest.description, last_update: null,
+        provider_code: newest.provider_code, last_status_text: newest.description, last_update: newest.time ?? null,
         last_update_local: newest.local_time, expected_delivery: null, events: events.slice(0, 100),
         ...(events.length > 100 ? { history_truncated: true } : {}) };
 }

package/dist/carriers/correios-br/carrier.json

@@ -1,7 +1,9 @@
 {
   "id": "correios-br",
   "displayName": "Correios Brazil",
-  "aliases": [],
+  "aliases": [
+    "Brazil Post"
+  ],
   "region": {
     "countries": [
       "BR"

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

@@ -16,6 +16,8 @@ const EXACT = new Map([
     // The recipient's duties or fees are paid; the clearance they held up completes next.
     ['payment is received and recorded for shipment related fees', 'customs'],
     ['shipment is in transit to destination', 'in_transit'],
+    // Waiting at a facility for the next linehaul or flight: on its way, not held.
+    ['scheduled to depart on the next planned movement', 'in_transit'],
     ['shipment is out with courier for delivery', 'out_for_delivery'],
     ['shipment is on hold', 'exception'],
     ['delivered', 'delivered'],
@@ -43,12 +45,13 @@ const PREFIXES = [
  * DHL's event codes on the unified feed, each seen with the wording above: SA
  * the shipment's acceptance, IC its processing for clearance, CD a clearance
  * step without its outcome, PY the payment of fees during clearance, MS a
- * missort, CC the wait for the consignee's collection, ND a delivery attempt
- * that could not be completed, RT the return to the shipper. They stage a scan
+ * missort, SM the wait for the next planned movement, CC the wait for the
+ * consignee's collection, ND a delivery attempt that could not be completed,
+ * RT the return to the shipper. They stage a scan
  * whose wording the map does not know, as in another language.
  */
 const CODES = new Map([
-    ['SA', 'accepted'], ['IC', 'customs'], ['CD', 'customs'], ['PY', 'customs'], ['MS', 'exception'],
+    ['SA', 'accepted'], ['IC', 'customs'], ['CD', 'customs'], ['PY', 'customs'], ['MS', 'exception'], ['SM', 'in_transit'],
     ['CC', 'ready_for_pickup'], ['ND', 'failed_attempt'], ['RT', 'returned'],
 ]);
 /** The checkpoint's stage from DHL's own wording, if the wording is one of DHL's checkpoints. */

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

@@ -83,6 +83,15 @@
       "firstSeen": "2026-10-05",
       "note": "Followed by the facility; matched on its start."
     },
+    {
+      "code": "SM",
+      "wording": "Scheduled to depart on the next planned movement",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-20",
+      "note": "Waiting at a facility for its next linehaul or flight. The unified feed codes it SM; the mobile API sends the wording alone."
+    },
     {
       "wording": "Shipment has departed from a DHL facility",
       "language": "en",

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

@@ -16,9 +16,9 @@ import { classifyStatus, comparableText, includesAny } from './status.js';
 // - One page can describe two parcels: an outbound number and its return
 //   number. The requested number decides which leg is read; the other leg's
 //   rows never enter the result.
-// - Cloudflare normally challenges anonymous direct requests, so the page is
-//   fetched directly first and through the private browser service's native
-//   scrape API when that request is challenged.
+// - Cloudflare challenges every anonymous direct request, so the page is
+//   fetched through the private browser service's native scrape API when one
+//   is configured, and directly only without one.
 const TRACKING_BASE = 'https://trace.dpd.fr/fr/trace';
 const TIMEZONE = 'Europe/Paris';
 const DEFAULT_TIMEOUT_MS = 90_000;
@@ -233,9 +233,9 @@ export class DPDFranceTracker {
                 return await this.directGet(url, capped(this.directTimeoutMs, timeoutMs), signal);
             }
             catch (error) {
-                // Without a browser service there is no second tier, so the
-                // challenge has to carry the operator's next step itself.
-                if (trawl || !(error instanceof DPDFranceChallengeError))
+                // The GET runs only without a browser service, so the challenge has
+                // to carry the operator's next step itself.
+                if (!(error instanceof DPDFranceChallengeError))
                     throw error;
                 throw new DPDFranceChallengeError('DPD France requires a browser challenge solver; configure FLARESOLVERR_URL');
             }
@@ -243,14 +243,15 @@ export class DPDFranceTracker {
         const html = await runSteps({
             carrier: 'dpd-fr', budgetMs: context.budgetMs ?? this.budgetMs, signal: context.signal, recorder: this.recorder,
         }, [
-            // A GET that fails to reach DPD, or hangs, is sent once more: the first
-            // gets at most half of what is left, so the second fits in the rest.
-            { id: 'direct', run: ({ remainingMs, signal }) => direct(firstAttemptMs(remainingMs), signal) },
-            networkRetryStep(({ remainingMs, signal }) => direct(remainingMs, signal)),
+            // Cloudflare challenges every plain GET, so a browser service, when
+            // there is one, is asked at once. Without one, a GET that fails to
+            // reach DPD, or hangs, is sent once more: the first gets at most half
+            // of what is left, so the second fits in the rest.
+            { id: 'direct', enabled: trawl === null, run: ({ remainingMs, signal }) => direct(firstAttemptMs(remainingMs), signal) },
+            { ...networkRetryStep(({ remainingMs, signal }) => direct(remainingMs, signal)), enabled: trawl === null },
             {
                 id: 'trawl',
                 enabled: trawl !== null,
-                recovers: (error) => error instanceof DPDFranceChallengeError,
                 run: async ({ remainingMs, signal }) => {
                     const timeoutMs = capped(this.timeoutMs, remainingMs);
                     return (await trawl.scrape({
@@ -307,8 +308,7 @@ export const adapter = (environment) => {
     });
     return {
         id: 'dpd-fr',
-        // One direct HTML GET, then the browser service's native scrape API when
-        // Cloudflare challenges it.
+        // The browser service's native scrape API, or a direct HTML GET without one.
         steps: ['direct', 'retry', 'trawl'],
         track: (input, context) => tracker.fetch(input.number, context),
     };

package/dist/carriers/dpd-uk/parser.js

@@ -3,7 +3,7 @@ import { dpdParcelNumber } from '../../core/detection/dpd.js';
 import { normalizeTrackingNumber } from '../../core/detection/index.js';
 import { IndeterminateError, InvalidInputError, SchemaError } from '../../core/errors/index.js';
 import { classifyWording, languageStageStatus } from '../../core/status/index.js';
-import { explicitOffsetTime } from '../../core/time/index.js';
+import { explicitOffsetTime, isoTime } from '../../core/time/index.js';
 import { clean } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 export const PROVIDER = 'DPD UK';
@@ -83,15 +83,32 @@ function publicDescription(value) {
         return text;
     return text.replace(/(\bdelivered)\s+(?:to\s+.+|and\s+signed\s+(?:for\s+)?by\s+.+|signed\s+(?:for\s+)?by\s+.+)$/i, '$1');
 }
-function clockFields(clock) {
+/**
+ * DPD's group tracking service gives the scans of DPD's own network with
+ * London's offset, at the wall clocks this feed shows. The sender's data
+ * record, under the account's display name or `Sender`, comes from the same
+ * UK system. Partner networks abroad and Pickup shops may keep another clock.
+ */
+function onUkClock(recorder, sender) {
+    return recorder === 'DPD' || recorder === 'Sender' || (sender !== '' && recorder === sender);
+}
+/** A UK wall clock's instant, unless the clocks skip it when summer time starts. */
+function ukTime(local) {
+    const placed = isoTime(local, 'Europe/London');
+    return placed?.iso.startsWith(local) ? placed.iso : undefined;
+}
+function clockFields(clock, uk) {
     const shape = /^(\d{4}-\d{2}-\d{2})[ T]((?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d)(Z|[+-]\d{2}:?\d{2})?$/.exec(clock);
     if (!shape)
         return { provider_time_text: clock };
     const iso = `${shape[1]}T${shape[2]}${shape[3] ?? ''}`;
     if (!DateTime.fromISO(iso, { zone: 'UTC', setZone: true }).isValid)
         return { provider_time_text: clock };
-    if (!shape[3])
-        return { local_time: `${shape[1]}T${shape[2]}` };
+    if (!shape[3]) {
+        const local = `${shape[1]}T${shape[2]}`;
+        const time = uk ? ukTime(local) : undefined;
+        return time ? { time } : { local_time: local };
+    }
     const offset = /[+-](\d{2}):?(\d{2})$/.exec(iso);
     if (offset && (Number(offset[1]) > 14 || Number(offset[2]) > 59 || (Number(offset[1]) === 14 && Number(offset[2]) !== 0))) {
         return { provider_time_text: clock };
@@ -107,6 +124,8 @@ export function parseDpdUkHistory(detailPayload, historyPayload, raw, code) {
         throw new SchemaError(PROVIDER);
     if (!historyPayload.data.length)
         throw new IndeterminateError(PROVIDER, 'DPD UK returned no parcel history');
+    // The account that booked the parcel: the shop whose name the page shows.
+    const sender = isRecord(detail.shipperDetails) ? clean(detail.shipperDetails.customerDisplayName, 120) : '';
     // The official page renders these rows newest first. Do not reorder uncertain clocks.
     const events = historyPayload.data.map(row => {
         if (!isRecord(row))
@@ -120,7 +139,7 @@ export function parseDpdUkHistory(detailPayload, historyPayload, raw, code) {
             throw new SchemaError(PROVIDER, 'DPD UK returned an incomplete scan');
         const classification = classifyDpdUkWording(description);
         // `eventLocation` names the network or the sender that recorded the scan, not a place.
-        return { description, ...clockFields(clock),
+        return { description, ...clockFields(clock, onUkClock(clean(row.eventLocation, 120), sender)),
             ...(classification.source !== 'none' ? { stage: classification.stage, stage_source: classification.source } : {}) };
     });
     const seen = new Set();
@@ -135,8 +154,6 @@ export function parseDpdUkHistory(detailPayload, historyPayload, raw, code) {
     const summary = publicDescription(detail.trackingStatusCurrent);
     const summaryClassification = classifyDpdUkWording(summary);
     const current = summary ? summaryClassification : classifyDpdUkWording(latest.description);
-    // The account that booked the parcel: the shop whose name the page shows.
-    const sender = isRecord(detail.shipperDetails) ? clean(detail.shipperDetails.customerDisplayName, 120) : '';
     return { status: current.source !== 'none' ? languageStageStatus(current.stage) : 'unknown',
         ...(current.source !== 'none' ? { current_stage: current.stage, current_stage_source: current.source } : {}),
         last_status_text: summary || latest.description, last_update: latest.time ?? null,

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

@@ -29,6 +29,13 @@ export declare class ImileTracker {
         now?: () => number;
         signing?: Readonly<ImileSigning>;
     });
-    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+    /**
+     * iMile's answer, with Cainiao's leg in front of its history unless
+     * `cainiao` is false. Cainiao is asked only once iMile has answered with
+     * scans, and its failure leaves iMile's answer as it is.
+     */
+    fetch(raw: string, context?: TrackingContext, { cainiao }?: {
+        cainiao?: boolean;
+    }): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/imile/adapter.js

@@ -1,10 +1,12 @@
 import { constants, createHash, createPublicKey, publicEncrypt } from 'node:crypto';
 import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
-import { ChallengeError, NotFoundError, SchemaError, TransportError } from '../../core/errors/index.js';
+import { BudgetExceededError, ChallengeError, NotFoundError, SchemaError, TransportError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
 import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
-import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { errorTypeOf, NOOP_RECORDER, outcomeOf, safeRecorder } from '../../core/telemetry/index.js';
 import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
+import { CainiaoTracker } from '../aliexpress/adapter.js';
+import { CAINIAO, cainiaoScans, withCainiaoLeg } from './cainiao.js';
 import { IMILE_MAX_BYTES, normalizeImileNumber, parseImile, PROVIDER } from './parser.js';
 const ORIGIN = 'https://www.imile.com';
 /** The lookup the tracking page on www.imile.com makes for the number in its address. */
@@ -26,6 +28,11 @@ const SCRIPT_KEY = /setPublicKey\("([A-Za-z0-9+/]{200,1000}={0,2})"\)/;
 const SCRIPT_SALT = /\.MD5\(""\.concat\([\w$]+,"([\w-]{1,64})"\)\)/;
 // Bot checks Cloudflare, in front of the site, could put in place of a reply.
 const CHALLENGE = /_cf_chl_opt|cf-turnstile|challenge-platform|<title>\s*(?:Just a moment|Attention Required)/i;
+const DEFAULT_BUDGET_MS = 20_000;
+// Cainiao answers within a second or two; it gets half of what iMile left, at most this.
+const CAINIAO_MS = 8_000;
+// Less than this left for Cainiao is no time for a request.
+const CAINIAO_MIN_MS = 250;
 function publicKey(key) {
     return createPublicKey({ key: Buffer.from(key, 'base64'), format: 'der', type: 'spki' });
 }
@@ -66,12 +73,28 @@ export class ImileTracker {
     #signing;
     // When the page last showed the values in use.
     #checkedAt = Number.NEGATIVE_INFINITY;
+    #cainiao;
     constructor(options = {}) {
         this.options = options;
         this.#signing = options.signing ?? IMILE_SIGNING;
+        this.#cainiao = new CainiaoTracker({ fetcher: options.fetcher, userAgent: options.userAgent, timeoutMs: CAINIAO_MS });
     }
-    async fetch(raw, context = {}) {
+    /**
+     * iMile's answer, with Cainiao's leg in front of its history unless
+     * `cainiao` is false. Cainiao is asked only once iMile has answered with
+     * scans, and its failure leaves iMile's answer as it is.
+     */
+    async fetch(raw, context = {}, { cainiao = true } = {}) {
         const number = normalizeImileNumber(raw);
+        const started = performance.now();
+        const budgetMs = context.budgetMs ?? DEFAULT_BUDGET_MS;
+        let attempts = 0;
+        const result = await this.#imile(number, { signal: context.signal, budgetMs }, (attempt) => { attempts = attempt; });
+        if (!cainiao)
+            return result;
+        return this.#withCainiao(number, result, context.signal, budgetMs - (performance.now() - started), attempts + 1);
+    }
+    async #imile(number, context, attempted) {
         const read = async (signal, timeoutMs) => {
             const deadline = performance.now() + timeoutMs;
             const left = () => Math.max(1, Math.floor(deadline - performance.now()));
@@ -92,12 +115,40 @@ export class ImileTracker {
         };
         // A request that fails to reach the site, or hangs, gets one more try: the
         // first gets half of the budget, so the retry fits in the rest.
-        return runSteps({ carrier: 'imile', budgetMs: context.budgetMs ?? 20_000, signal: context.signal,
+        return runSteps({ carrier: 'imile', budgetMs: context.budgetMs, signal: context.signal,
             recorder: this.options.recorder ?? NOOP_RECORDER }, [
-            { id: 'direct', run: ({ signal, remainingMs }) => read(signal, firstAttemptMs(remainingMs)) },
-            networkRetryStep(({ signal, remainingMs }) => read(signal, remainingMs)),
+            { id: 'direct', run: ({ signal, remainingMs, attempt }) => { attempted(attempt); return read(signal, firstAttemptMs(remainingMs)); } },
+            networkRetryStep(({ signal, remainingMs, attempt }) => { attempted(attempt); return read(signal, remainingMs); }),
         ]);
     }
+    /**
+     * Cainiao's leg of the parcel in front of iMile's history, recorded as the
+     * `cainiao` step. Cainiao gets half of the time iMile left, so iMile's
+     * answer comes back inside the budget whatever Cainiao does. Any failure,
+     * a challenge, a rate limit, an unknown number or a changed reply, is
+     * recorded with its kind and returns iMile's answer unchanged.
+     */
+    async #withCainiao(number, result, signal, remainingMs, attempt) {
+        const recorder = safeRecorder(this.options.recorder ?? NOOP_RECORDER);
+        const started = performance.now();
+        const record = (error) => recorder.step({
+            carrier: 'imile', step: 'cainiao', attempt, outcome: error === undefined ? 'ok' : outcomeOf(error),
+            errorType: error === undefined ? null : errorTypeOf(error), durationMs: Math.max(0, performance.now() - started),
+            fallbackFrom: null, fallbackReason: null, fallbackErrorType: null, ...(error === undefined ? {} : { error }),
+        });
+        const budgetMs = Math.min(CAINIAO_MS, Math.floor(remainingMs / 2));
+        try {
+            if (budgetMs < CAINIAO_MIN_MS)
+                throw new BudgetExceededError(CAINIAO, budgetMs);
+            const merged = withCainiaoLeg(result, cainiaoScans(await this.#cainiao.detail(number, { signal, budgetMs }), number));
+            record();
+            return merged;
+        }
+        catch (error) {
+            record(error);
+            return result;
+        }
+    }
     async #query(number, signing, signal, timeoutMs) {
         const { code, sign } = imileSignature(number, signing);
         const { response, bytes } = await fetchBounded(`${IMILE_API}?waybillNo=${encodeURIComponent(number)}&code=${code}`, { method: 'GET', signal,
@@ -138,8 +189,9 @@ export class ImileTracker {
 export const adapter = (environment) => {
     const tracker = new ImileTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
     return {
-        id: 'imile', recordsSteps: true, steps: ['direct', 'retry'],
+        id: 'imile', recordsSteps: true, steps: ['direct', 'retry', 'cainiao'],
         track: (input, context) => tracker.fetch(input.number, context),
-        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeImileNumber(number))),
+        // Recognition asks iMile alone: Cainiao's record of a number is no evidence that iMile knows it.
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context, { cainiao: false }), () => accepted(() => normalizeImileNumber(number))),
     };
 };

package/dist/carriers/imile/cainiao.d.ts

@@ -0,0 +1,18 @@
+import type { CarrierEvent, CarrierResult } from '../../core/result/index.js';
+export declare const CAINIAO = "Cainiao";
+/**
+ * Cainiao's scans of an iMile parcel, from its `detail.json` reply for the
+ * number. The record must name iMile as a carrier of the parcel: the same
+ * number in Cainiao's feed may be another network's parcel. A scan Cainiao
+ * does not place keeps its wall clock in `local_time`, as iMile's do.
+ */
+export declare function cainiaoScans(payload: unknown, number: string): CarrierEvent[];
+/**
+ * iMile's answer with Cainiao's scans from before iMile handled the parcel.
+ * iMile handles it from its first scan with a stage past its order record,
+ * such as a pickup, a flight or a centre: Cainiao's scans count only up to
+ * the last one that is older at every reading, and a scan both report stays
+ * iMile's. Before iMile's first such scan, its order record is all it has,
+ * and the newest scan of either feed gives the status.
+ */
+export declare function withCainiaoLeg(imile: CarrierResult, cainiao: readonly CarrierEvent[]): CarrierResult;

package/dist/carriers/imile/cainiao.js

@@ -0,0 +1,109 @@
+/**
+ * Cainiao's leg of the parcels it hands to iMile.
+ *
+ * iMile's tracker starts with its order record and its own centres. For a
+ * parcel Cainiao carries out of China, Cainiao's global tracker holds the
+ * pickup, sorting, export, flight and import scans under the same iMile
+ * number, then relays iMile's own scans at their own clocks. Those older scans
+ * go in front of iMile's history; iMile's own scans stay as iMile gave them.
+ */
+import { IndeterminateError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { cainiaoCarrierNames, parseCainiaoTrackingResponse } from '../aliexpress/adapter.js';
+import { imileSummary } from './parser.js';
+export const CAINIAO = 'Cainiao';
+/** How Cainiao names iMile as the parcel's destination carrier or a scan's carrier ("Imile"). */
+const IMILE_NAME = /^imile\b/;
+const WALL_CLOCK = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}:\d{2})?$/;
+// A clock without an offset may be any instant up to 14 hours before its wall time.
+const EARLIEST_OFFSET_MS = 14 * 3_600_000;
+const SUMMARY_KEYS = ['status', 'current_stage', 'current_stage_source', 'last_status_text', 'last_update', 'last_update_local'];
+/**
+ * Cainiao's scans of an iMile parcel, from its `detail.json` reply for the
+ * number. The record must name iMile as a carrier of the parcel: the same
+ * number in Cainiao's feed may be another network's parcel. A scan Cainiao
+ * does not place keeps its wall clock in `local_time`, as iMile's do.
+ */
+export function cainiaoScans(payload, number) {
+    const events = parseCainiaoTrackingResponse(payload, number).events ?? [];
+    if (!events.length)
+        return [];
+    if (![...cainiaoCarrierNames(payload, number)].some((name) => IMILE_NAME.test(name))) {
+        throw new IndeterminateError(CAINIAO, 'Cainiao does not name iMile as a carrier of the parcel', { reason: 'carrier_unconfirmed' });
+    }
+    return events.flatMap(({ time, local_time, location, stage, stage_source, ...event }) => {
+        const clock = typeof time === 'string' && time ? time : typeof local_time === 'string' ? local_time : '';
+        if (!event.description || !clock)
+            return [];
+        const placed = explicitOffsetTime(clock) ? { time: clock } : WALL_CLOCK.test(clock) ? { local_time: clock.replace(' ', 'T') } : null;
+        if (!placed)
+            return [];
+        return [{ ...placed, ...(location ? { location } : {}), ...event,
+                ...(stage ? { stage, stage_source: typeof stage_source === 'string' ? stage_source : 'carrier_map' } : {}) }];
+    });
+}
+function clockOf(event) {
+    const time = typeof event.time === 'string' ? event.time : '';
+    const placed = explicitOffsetTime(time);
+    if (placed)
+        return { instant: placed.timestamp, wall: time.slice(0, 19), earliest: placed.timestamp, key: placed.timestamp };
+    const wall = (typeof event.local_time === 'string' ? event.local_time : time).replace(' ', 'T');
+    const read = WALL_CLOCK.test(wall) ? Date.parse(`${wall.length === 10 ? `${wall}T00:00:00` : wall}Z`) : Number.NaN;
+    const key = Number.isFinite(read) ? read : Number.NEGATIVE_INFINITY;
+    return { instant: null, wall, earliest: key - EARLIEST_OFFSET_MS, key };
+}
+/** The same scan in both feeds: Cainiao relays iMile's scans on iMile's own wall clock. */
+function sameScan(cainiao, imile) {
+    if (cainiao.instant !== null && imile.instant !== null)
+        return cainiao.instant === imile.instant;
+    return cainiao.wall.length === 19 && cainiao.wall === imile.wall;
+}
+/** Two histories newest first in one, each in its own order; iMile's scan first when they sort alike. */
+function interleave(imile, cainiao) {
+    const merged = [];
+    let i = 0;
+    let c = 0;
+    while (i < imile.length || c < cainiao.length) {
+        const takeImile = c >= cainiao.length || (i < imile.length && clockOf(imile[i]).key >= clockOf(cainiao[c]).key);
+        merged.push(takeImile ? imile[i++] : cainiao[c++]);
+    }
+    return merged;
+}
+/**
+ * iMile's answer with Cainiao's scans from before iMile handled the parcel.
+ * iMile handles it from its first scan with a stage past its order record,
+ * such as a pickup, a flight or a centre: Cainiao's scans count only up to
+ * the last one that is older at every reading, and a scan both report stays
+ * iMile's. Before iMile's first such scan, its order record is all it has,
+ * and the newest scan of either feed gives the status.
+ */
+export function withCainiaoLeg(imile, cainiao) {
+    const own = imile.events ?? [];
+    // A history cut short has lost its oldest scans, which Cainiao's leg would go behind.
+    if (!own.length || !cainiao.length || imile.history_truncated)
+        return imile;
+    const ownClocks = own.map(clockOf);
+    const handled = own.flatMap((event, index) => (event.stage && event.stage !== 'registered' ? [index] : []));
+    const cut = handled.length ? Math.min(...handled.map((index) => ownClocks[index].earliest)) : Number.POSITIVE_INFINITY;
+    // Cainiao lists its scans newest first: its leg starts at its newest scan older than iMile's first.
+    const start = cainiao.findIndex((event) => {
+        const { instant } = clockOf(event);
+        return instant !== null && instant < cut;
+    });
+    const leg = (start < 0 ? [] : cainiao.slice(start)).filter((event) => {
+        const clock = clockOf(event);
+        return !(clock.instant !== null && clock.instant >= cut) && !ownClocks.some((other) => sameScan(clock, other));
+    });
+    if (!leg.length)
+        return imile;
+    if (handled.length) {
+        const kept = handled.at(-1) + 1;
+        return { ...imile, events: [...own.slice(0, kept), ...interleave(own.slice(kept), leg)] };
+    }
+    const events = interleave(own, leg);
+    // The merged history's summary replaces iMile's whole: no key of iMile's stays beside it.
+    const rest = { ...imile };
+    for (const key of SUMMARY_KEYS)
+        delete rest[key];
+    return { ...imileSummary(events), ...rest, events };
+}

package/dist/carriers/imile/carrier.json

@@ -27,7 +27,8 @@
     "adapter": "imile",
     "steps": [
       "direct",
-      "retry"
+      "retry",
+      "cainiao"
     ],
     "recognition": {
       "rank": 997

package/dist/carriers/imile/parser.d.ts

@@ -1,4 +1,4 @@
-import type { CarrierResult } from '../../core/result/index.js';
+import type { CarrierEvent, CarrierResult } from '../../core/result/index.js';
 export declare const PROVIDER = "iMile";
 export declare const IMILE_MAX_BYTES: number;
 /** A number for iMile's tracker, in upper case; anything else is not one it answers. */
@@ -16,3 +16,5 @@ export declare function imileWording(raw: string): string;
  * found. A shipment must name the number asked.
  */
 export declare function parseImile(payload: unknown, raw: string): CarrierResult;
+/** The status a history newest first gives: its newest staged scan's stage, and its newest scan's wording and clock. */
+export declare function imileSummary(events: readonly CarrierEvent[]): CarrierResult;

package/dist/carriers/imile/parser.js

@@ -155,9 +155,6 @@ export function parseImile(payload, raw) {
         throw new NoHistoryError(PROVIDER);
     // Newest first, as the page lists them; an oldest-first reply is turned round.
     const newestFirst = events[0].local_time < events.at(-1).local_time ? events.reverse() : events;
-    const newest = newestFirst[0];
-    const current = newestFirst.find((event) => event.stage);
-    const stage = current?.stage;
     const code = text(shipment, 'country', 8).toUpperCase();
     const country = Object.hasOwn(COUNTRIES, code) ? COUNTRIES[code] : undefined;
     // Every scan shows the recipient country's clock: a country of one zone
@@ -167,16 +164,24 @@ export function parseImile(payload, raw) {
         const time = isoTime(local_time, zone)?.iso;
         return time ? { time, ...event } : { local_time, ...event };
     }) : newestFirst;
-    const latest = placed[0];
     return {
-        status: stage ? languageStageStatus(stage) : 'unknown',
-        ...(stage ? { current_stage: stage, current_stage_source: current.stage_source } : {}),
-        last_status_text: newest.description,
-        last_update: latest.time ?? null,
-        ...(latest.time ? {} : { last_update_local: newest.local_time }),
+        ...imileSummary(placed),
         expected_delivery: null,
         ...(country ? { destination_country: country } : {}),
         events: placed.slice(0, MAX_EVENTS),
         ...(newestFirst.length > MAX_EVENTS ? { history_truncated: true } : {}),
     };
 }
+/** The status a history newest first gives: its newest staged scan's stage, and its newest scan's wording and clock. */
+export function imileSummary(events) {
+    const newest = events[0];
+    const current = events.find((event) => event.stage);
+    const stage = current?.stage;
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: current.stage_source } : {}),
+        last_status_text: newest.description,
+        last_update: newest.time ?? null,
+        ...(newest.time ? {} : { last_update_local: newest.local_time }),
+    };
+}

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

@@ -9,4 +9,5 @@ export declare function imileMappedStage(code: string, wording: string): Stage |
  * A delivery-stage scan they do not read stays in transit as the fallback.
  */
 export declare function imileStage(code: string, wording: string): ClassifiedWording | null;
+/** iMile's map for its own scans, and Cainiao's for the scans of Cainiao's leg in front of them. */
 export declare const statusMap: CarrierStatusMap;

package/dist/carriers/imile/status.js

@@ -1,4 +1,5 @@
 import { classifyWording } from '../../core/status/index.js';
+import { statusMap as cainiaoStatusMap } from '../aliexpress/status.js';
 /**
  * iMile's `trackStage` codes, by the label the reply gives them. Delivered,
  * returned and return handling decide the stage whatever the wording says.
@@ -108,9 +109,15 @@ export function imileStage(code, wording) {
     const worded = classifyWording(wording, 'in_transit');
     return worded.source === 'none' && code !== DELIVERY ? null : worded;
 }
+/** iMile's own codes are numbers; Cainiao's action codes, on the scans of its leg, are words. */
+const IMILE_CODE = /^\d{1,6}$/;
+/** iMile's map for its own scans, and Cainiao's for the scans of Cainiao's leg in front of them. */
 export const statusMap = {
-    stage: (code, wording) => imileMappedStage(code ?? '', wording) ?? undefined,
+    stage: (code, wording) => (code && !IMILE_CODE.test(code)
+        ? cainiaoStatusMap.stage(code, wording)
+        : imileMappedStage(code ?? '', wording) ?? undefined),
     gaps: [
         { code: DELIVERY, wording: 'lost order', note: 'A driver\'s reason during a delivery run, followed by the attempt\'s end; the parcel it was seen on went out again and was delivered, so it does not establish a loss.' },
+        ...cainiaoStatusMap.gaps,
     ],
 };

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

@@ -25,16 +25,27 @@ const COUNTRY_NAMES = {
 // and Portugal on their islands, France in the overseas departments Japan
 // Post's France covers. A delivery scan names no office, only the country.
 const OVERSEAS_CLOCKS = new Set(['ES', 'FR', 'PT']);
+// Offices of exchange on the mainland of those countries, by the name the UPU
+// code list gives them: Correos' Madrid airport office is `MADRID AP`.
+const MAINLAND_OFFICES = {
+    ES: { office: /^MADRID(?: |$)/, zone: 'Europe/Madrid' },
+};
 // The history header states that overseas scans are in local time, the clock
 // of the post that scanned. A row's own Prefecture / Country cell settles its
-// zone when it names a prefecture or a single-zone country. The office,
-// another scan's zone or the parcel's destination never does.
-function rowZone(region) {
+// zone when it names a prefecture or a single-zone country, and its own office
+// when that is a mainland office of exchange of a country with other clocks.
+// Another scan's zone or the parcel's destination never does.
+function rowZone(region, office) {
     const name = region.toUpperCase();
     if (PREFECTURES.has(name))
         return 'Asia/Tokyo';
     const code = Object.hasOwn(COUNTRY_NAMES, name) ? COUNTRY_NAMES[name] : countryCode(name);
-    return code && !OVERSEAS_CLOCKS.has(code) ? countryTimeZone(code) : null;
+    if (!code)
+        return null;
+    if (!OVERSEAS_CLOCKS.has(code))
+        return countryTimeZone(code);
+    const mainland = Object.hasOwn(MAINLAND_OFFICES, code) ? MAINLAND_OFFICES[code] : null;
+    return mainland?.office.test(office.toUpperCase()) ? mainland.zone : null;
 }
 export function normalizeJapanPostNumber(raw) {
     const number = normalizeTrackingNumber(raw);
@@ -55,8 +66,8 @@ function wallTime(raw) {
         throw new SchemaError(PROVIDER, 'Japan Post returned an invalid event date');
     return date.toFormat(format === 'MM/dd/yyyy' ? 'yyyy-MM-dd' : "yyyy-MM-dd'T'HH:mm:ss");
 }
-function eventInstant(localTime, region) {
-    const zone = rowZone(region);
+function eventInstant(localTime, region, office) {
+    const zone = rowZone(region, office);
     if (!zone || !localTime.includes('T'))
         return null;
     const date = firstOccurrence(DateTime.fromISO(localTime, { zone }));
@@ -142,8 +153,9 @@ export function parse(html, trackingNumber) {
         if (!description)
             throw new SchemaError(PROVIDER, 'Japan Post returned an empty event');
         const region = clean(cells.eq(4).text(), 100);
-        const location = [clean(cells.eq(3).text(), 150), region].filter(Boolean).join(', ');
-        const time = eventInstant(localTime, region);
+        const office = clean(cells.eq(3).text(), 150);
+        const location = [office, region].filter(Boolean).join(', ');
+        const time = eventInstant(localTime, region, office);
         const status = japanPostStatus(description);
         // The host treats `time` as an instant and applies the catalog's timezone
         // when no offset is present. Keep unresolved wall clocks in local_time.

package/dist/carriers/tsjy/parser.js

@@ -2,6 +2,7 @@ import { DateTime } from 'luxon';
 import { detectCarrierMatch, normalizeTrackingNumber } from '../../core/detection/index.js';
 import { IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
 import { languageStageStatus } from '../../core/status/index.js';
+import { normalizeStatusWording } from '../../core/status/statusMap.js';
 import { cleanScalar } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { normalizeSeventeenFeiaNumber } from '../17feia/parser.js';
@@ -18,6 +19,20 @@ const EARLIEST = Date.UTC(2015, 0, 1);
 const MAX_ORDERS = 20;
 const MAX_ROWS = 500;
 const MAX_EVENTS = 100;
+/**
+ * 17FEIA's rows from its warehouse in China up to the export declaration.
+ * 17FEIA writes them on Beijing time, so TSJY's reading of them is their
+ * instant.
+ */
+const SEVENTEENFEIA_WAREHOUSE_ROWS = new Set([
+    'item information received.',
+    'the package is on the way to the facility.',
+    'warehouse receipt.',
+    'the order has information pending customer confirmation.',
+    'order confirmed.',
+    'order dispatched from warehouse.',
+    'export declaration in progress.',
+]);
 /**
  * The lines TSJY hands orders to, by the catalog id that tracks them and the
  * check that the line's number is one of its own. A channel number no line
@@ -52,16 +67,16 @@ function text(record, key, maxLength = 500) {
 /**
  * A row's clock. TSJY's server stamps its own steps with milliseconds: those
  * are instants. A partner's rows come in whole seconds, its wall clocks read
- * on Beijing time, which is right for 17FEIA's Chinese warehouse and unknown
- * elsewhere, so they keep that wall clock.
+ * on Beijing time, which is right for 17FEIA's rows from its warehouse in
+ * China and unknown elsewhere, so the others keep that wall clock.
  */
-function clockOf(stamp) {
+function clockOf(stamp, warehouse) {
     const home = DateTime.fromMillis(stamp, { zone: HOME_ZONE });
-    if (stamp % 1000 !== 0)
+    if (stamp % 1000 !== 0 || warehouse)
         return { time: home.startOf('second').toISO({ suppressMilliseconds: true }) };
     return { local_time: home.toFormat("yyyy-MM-dd'T'HH:mm:ss") };
 }
-function projectRow(row, readAt) {
+function projectRow(row, readAt, seventeenFeia) {
     if (!isRecord(row))
         throw new SchemaError(PROVIDER, 'TSJY returned an invalid scan');
     const stamp = row.date;
@@ -75,7 +90,7 @@ function projectRow(row, readAt) {
     const location = text(row, 'loc', 200);
     const staged = tsjyStage(description);
     const event = {
-        ...clockOf(stamp),
+        ...clockOf(stamp, seventeenFeia && SEVENTEENFEIA_WAREHOUSE_ROWS.has(normalizeStatusWording(description))),
         description,
         ...(location ? { location } : {}),
         ...(staged ? { stage: staged.stage, stage_source: staged.source } : {}),
@@ -128,10 +143,11 @@ export function parseTsjy(payload, raw, readAt = Date.now()) {
         throw new SchemaError(PROVIDER, 'TSJY returned an order without scans');
     if (rows.length > MAX_ROWS)
         throw new SchemaError(PROVIDER, 'TSJY returned an oversized history');
+    const line = tsjyHandoff(text(order, 'channelNo', 64), number);
     const seen = new Set();
     const scans = [];
     for (const row of rows) {
-        const scan = projectRow(row, readAt);
+        const scan = projectRow(row, readAt, line?.delivery_carrier === '17feia');
         if (!scan || seen.has(scan.key))
             continue;
         seen.add(scan.key);
@@ -152,7 +168,7 @@ export function parseTsjy(payload, raw, readAt = Date.now()) {
         ...(newest.local_time ? { last_update_local: newest.local_time } : {}),
         expected_delivery: null,
         ...(stage === 'delivered' && current.time ? { delivered_at: current.time } : {}),
-        ...tsjyHandoff(text(order, 'channelNo', 64), number),
+        ...line,
         events: events.slice(0, MAX_EVENTS),
         ...(events.length > MAX_EVENTS ? { history_truncated: true } : {}),
     };

package/dist/carriers/ups/status.js

@@ -48,15 +48,14 @@ const ACTIVITY_STAGES = new Map([
     // Shipper created a label; UPS does not have the parcel yet.
     ['MP', 'registered'],
     // Drop-off at an access point, the access point readying it for UPS, a
-    // pickup scan, the RFID-confirmed collection from the access point, and the
-    // origin scan.
-    ['XD', 'accepted'], ['ZO', 'accepted'], ['PU', 'accepted'], ['PC', 'accepted'], ['OR', 'accepted'],
+    // pickup scan, the RFID-confirmed collection from the access point, the
+    // parcel on its way to its first UPS facility, and the origin scan there.
+    ['XD', 'accepted'], ['ZO', 'accepted'], ['PU', 'accepted'], ['PC', 'accepted'], ['AG', 'accepted'], ['OR', 'accepted'],
     // Facility scans, export and import scans.
     ['AR', 'in_transit'], ['DP', 'in_transit'], ['DS', 'in_transit'], ['YP', 'in_transit'], ['HL', 'in_transit'],
     ['EP', 'in_transit'], ['IP', 'in_transit'],
-    // A notice that the package is on its way, without a facility, and one that
-    // it is on its way to a UPS facility.
-    ['DA', 'in_transit'], ['AG', 'in_transit'],
+    // A notice that the package is on its way, without a facility.
+    ['DA', 'in_transit'],
     // Delays and new delivery plans: a late flight, a possible delay, a new
     // plan, a delivery a day early.
     ['18', 'in_transit'], ['Q5', 'in_transit'], ['E3', 'in_transit'], ['2U', 'in_transit'],

package/dist/carriers/ups/statuses.json

@@ -19,7 +19,7 @@
     { "code": "YP", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-07", "note": "actCode: \"Processing at UPS Facility\"." },
     { "code": "HL", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-16", "note": "actCode: \"Your package was processed at our facility.\"" },
     { "code": "DA", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-18", "note": "actCode: \"Your package is on the way\", without a location." },
-    { "code": "AG", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-20", "note": "actCode: \"Package is in transit to a UPS facility\"." },
+    { "code": "AG", "language": "en", "stage": "accepted", "confirmedBy": "live", "firstSeen": "2026-10-20", "note": "actCode: \"Package is in transit to a UPS facility\", seen before the origin scan: UPS has the parcel, not yet at a facility." },
     { "code": "EP", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-07", "note": "actCode: \"Export Scan\"." },
     { "code": "IP", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-07", "note": "actCode: \"Import Scan\"." },
     { "code": "18", "language": "en", "stage": "in_transit", "confirmedBy": "live", "firstSeen": "2026-10-07", "note": "actCode: a late flight delayed the parcel, which still arrives that day." },

package/dist/carriers/yanwen/status.js

@@ -20,6 +20,7 @@ const WORDING = new Map([
     // among them: the parcel is in Yanwen's hands and has not moved yet.
     ['Processing information input', { status: 'in_transit', stage: 'accepted' }],
     ['shipping label created', { status: 'in_transit', stage: 'accepted' }],
+    ['Shipment order created', { status: 'in_transit', stage: 'accepted' }],
     ['Order processed by shipper', { status: 'pending', stage: 'registered' }],
     ['Order Submited.', { status: 'pending', stage: 'registered' }],
     ['Waybill Generated', { status: 'pending', stage: 'registered' }],

package/dist/carriers/yanwen/statuses.json

@@ -127,6 +127,14 @@
       "confirmedBy": "live",
       "firstSeen": "2026-10-17"
     },
+    {
+      "wording": "Shipment order created",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-20",
+      "note": "Written in the same second as Processing information input, after the pickup scan."
+    },
     {
       "wording": "Order processed by shipper",
       "language": "en",

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

@@ -1,4 +1,5 @@
 import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
 import { type StepRecorder } from '../../core/telemetry/index.js';
 export declare class YtoTracker {
     private readonly options;
@@ -7,6 +8,6 @@ export declare class YtoTracker {
         recorder?: StepRecorder;
         userAgent?: string;
     });
-    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/yto/adapter.js

@@ -1,5 +1,6 @@
 import { TransportError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
 import { NOOP_RECORDER } from '../../core/telemetry/index.js';
 import { fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { normalizeYtoNumber, parseYto } from './parser.js';
@@ -13,24 +14,30 @@ export class YtoTracker {
     }
     async fetch(raw, context = {}) {
         const number = normalizeYtoNumber(raw);
+        const read = async (signal, timeoutMs) => {
+            try {
+                const { bytes } = await fetchBounded(ENDPOINT, { method: 'POST', signal,
+                    headers: { 'Content-Type': 'application/json', source: 'PC', 'User-Agent': userAgentOf(this.options.userAgent) }, body: JSON.stringify([number]),
+                }, { provider: 'YTO Express', timeoutMs: Math.max(1, Math.floor(timeoutMs)), maxBytes: 1_000_000, fetcher: this.options.fetcher });
+                return parseYto(parseJsonBytes(bytes, 'YTO Express'), number);
+            }
+            catch (error) {
+                if (error instanceof UpstreamHttpError && [404, 410].includes(error.status)) {
+                    throw new TransportError('YTO Express', 'YTO tracking endpoint is unavailable', { cause: error });
+                }
+                throw error;
+            }
+        };
+        // A read that fails to reach the site, or hangs, gets one more try: the
+        // first gets half of the budget, so the retry fits in the rest.
         return runSteps({ carrier: 'yto', signal: context.signal, budgetMs: context.budgetMs ?? 15_000,
-            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
-                    try {
-                        const { bytes } = await fetchBounded(ENDPOINT, { method: 'POST', signal,
-                            headers: { 'Content-Type': 'application/json', source: 'PC', 'User-Agent': userAgentOf(this.options.userAgent) }, body: JSON.stringify([number]),
-                        }, { provider: 'YTO Express', timeoutMs: Math.max(1, Math.floor(remainingMs)), maxBytes: 1_000_000, fetcher: this.options.fetcher });
-                        return parseYto(parseJsonBytes(bytes, 'YTO Express'), number);
-                    }
-                    catch (error) {
-                        if (error instanceof UpstreamHttpError && [404, 410].includes(error.status)) {
-                            throw new TransportError('YTO Express', 'YTO tracking endpoint is unavailable', { cause: error });
-                        }
-                        throw error;
-                    }
-                } }]);
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [
+            { id: 'direct', run: ({ signal, remainingMs }) => read(signal, firstAttemptMs(remainingMs)) },
+            networkRetryStep(({ signal, remainingMs }) => read(signal, remainingMs)),
+        ]);
     }
 }
 export const adapter = environment => {
     const tracker = new YtoTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
-    return { id: 'yto', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+    return { id: 'yto', recordsSteps: true, steps: ['direct', 'retry'], track: (input, context) => tracker.fetch(input.number, context) };
 };

package/dist/carriers/yto/carrier.json

@@ -16,7 +16,8 @@
     "mode": "automatic",
     "adapter": "yto",
     "steps": [
-      "direct"
+      "direct",
+      "retry"
     ],
     "localClocks": true
   },

package/dist/core/catalog/hints.js

@@ -42,17 +42,19 @@ const CATALOG_NAMES = new Set([
 // from abroad, not for registered mail. Posta Kenya dates only scans it places
 // in Kenya by name. Correo Uruguayo's clocks name no zone, and those relayed
 // from abroad keep the sender's. Posta dates only scans at a Faroese place.
-// Correos de El Salvador's clocks name no zone either. The host also checks
-// adapter availability and required inputs before making a request.
+// Correos de El Salvador's clocks name no zone either. Correios Brazil names
+// each row's zone. The host also checks adapter availability and required
+// inputs before making a request.
 const NATIONAL_POSTS = new Map([
     ['AM', 'haypost'], ['AR', 'correo-argentino'], ['AU', 'australia-post'], ['BD', 'bangladesh-post'],
-    ['BG', 'bulgarian-posts'], ['BY', 'belpost'], ['CA', 'canada-post'], ['CH', 'swiss-post'], ['DE', 'dhl'],
-    ['DZ', 'algerie-poste'], ['EG', 'egypt-post'], ['ES', 'correos-spain'], ['FI', 'posti'], ['FO', 'posta-faroe'],
-    ['FR', 'la-poste'], ['GB', 'royal-mail'], ['IS', 'posturinn'], ['JO', 'jordan-post'], ['JP', 'japan-post'],
-    ['KE', 'posta-kenya'], ['MA', 'barid-al-maghrib'], ['MK', 'posta-north-macedonia'], ['NL', 'spring-gds'],
-    ['PH', 'phlpost'], ['PL', 'poczta-polska'], ['PT', 'ctt'], ['RO', 'posta-romana'], ['SA', 'saudi-post'],
-    ['SE', 'postnord'], ['SV', 'correos-el-salvador'], ['UA', 'ukrposhta'], ['US', 'usps'],
-    ['UY', 'correo-uruguayo'], ['UZ', 'uzbekistan-post'], ['ZA', 'south-african-post-office'],
+    ['BG', 'bulgarian-posts'], ['BR', 'correios-br'], ['BY', 'belpost'], ['CA', 'canada-post'],
+    ['CH', 'swiss-post'], ['DE', 'dhl'], ['DZ', 'algerie-poste'], ['EG', 'egypt-post'], ['ES', 'correos-spain'],
+    ['FI', 'posti'], ['FO', 'posta-faroe'], ['FR', 'la-poste'], ['GB', 'royal-mail'], ['IS', 'posturinn'],
+    ['JO', 'jordan-post'], ['JP', 'japan-post'], ['KE', 'posta-kenya'], ['MA', 'barid-al-maghrib'],
+    ['MK', 'posta-north-macedonia'], ['NL', 'spring-gds'], ['PH', 'phlpost'], ['PL', 'poczta-polska'],
+    ['PT', 'ctt'], ['RO', 'posta-romana'], ['SA', 'saudi-post'], ['SE', 'postnord'],
+    ['SV', 'correos-el-salvador'], ['UA', 'ukrposhta'], ['US', 'usps'], ['UY', 'correo-uruguayo'],
+    ['UZ', 'uzbekistan-post'], ['ZA', 'south-african-post-office'],
 ]);
 const englishCountries = new Intl.DisplayNames(['en'], { type: 'region' });
 // Deprecated codes carry their successor's name, so fold them into it ("FX" is France).

package/dist/data/catalog.json

@@ -3547,6 +3547,9 @@
     "correios-br": {
         "displayName": "Correios Brazil",
         "color": "#ffd500",
+        "aliases": [
+            "Brazil Post"
+        ],
         "countries": [
             "BR"
         ],

package/dist/generated/catalog.d.ts

@@ -2409,6 +2409,7 @@ export declare const CARRIER_CATALOG: {
     readonly "correios-br": {
         readonly displayName: "Correios Brazil";
         readonly color: "#ffd500";
+        readonly aliases: readonly ["Brazil Post"];
         readonly countries: readonly ["BR"];
         readonly selectable: true;
         readonly timezone: "UTC";

package/dist/generated/catalog.js

@@ -3548,6 +3548,9 @@ export const CARRIER_CATALOG = {
     "correios-br": {
         "displayName": "Correios Brazil",
         "color": "#ffd500",
+        "aliases": [
+            "Brazil Post"
+        ],
         "countries": [
             "BR"
         ],

package/dist/providers/shared/result.js

@@ -218,6 +218,14 @@ function providerWordingStage(description) {
         return 'in_transit';
     if (/^confirmation of preparation of the shipment received[.!]?$/i.test(value))
         return 'registered';
+    // Correios Brazil's scans in an aggregator's English for an item posted abroad. Correios' receipt follows
+    // the posting and the export, so it is transit here; the recipient still owes customs their tax number.
+    if (/^item posted[.!]?$/i.test(value))
+        return 'accepted';
+    if (/^item in transfer - please wait[.!]?$|^item received at the export unit in the country of origin[.!]?$|^item received by the brazilian post[.!]?$/i.test(value))
+        return 'in_transit';
+    if (/^need to inform (?:the )?recipient['’]?s cpf\/cnpj[.!]?$/i.test(value))
+        return 'customs';
     if (/^(?:received\.|(?:\d\) )?[a-z ]{1,40} cent(?:er|re)) your order has been received[.!]?$|^(?:\S+ )?cent(?:er|re) (?:received|parcel shipped to \S+)[.!]?$|^origin port warehouse receive\b|^the flight has taken off[.!]?$|^(?:\S+ )?dispatch task assigned to da[.!]?$/i.test(value))
         return 'in_transit';
     if (/^<bad address>$/i.test(value))

package/dist/server/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Universal Parcel Scraper",
-    "version": "0.576.0"
+    "version": "0.577.2"
   },
   "paths": {
     "/health": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-parcel-scraper",
-  "version": "0.576.0-main.2691",
+  "version": "0.577.2-main.2708",
   "description": "Self-hosted parcel tracking: carrier detection, dedicated scrapers and optional universal providers.",
   "type": "module",
   "license": "Apache-2.0",