universal-parcel-scraper 0.427.0-main.2176 → 0.428.0-main.2178

package/README.md

@@ -13,7 +13,7 @@ The engine behind [Peek](https://peektracker.com) ([GitHub](https://github.com/p
 [![License: Apache-2.0](https://img.shields.io/badge/core-Apache--2.0-blue.svg)](LICENSE)
 
 <!-- GENERATED:summary -->
-**3,500+ carriers** through **462 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **463 dedicated adapters** and **5 universal fallbacks**
 
 <sub>767 catalog entries · 134 countries represented</sub>
 <!-- /GENERATED:summary -->
@@ -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 14,493 such statuses, each filed under one stage.
+The carrier folders record 14,524 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

@@ -28429,7 +28429,8 @@
     "timezone": "Asia/Singapore",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "tracx-logis",
+      "recognitionRank": 777
     },
     "canaryUrl": "https://www.tracxlogis.com/tracking",
     "trackingUrlTemplate": "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}",

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 767,
-  "activeAdapters": 462,
+  "activeAdapters": 463,
   "countries": 134,
   "referenceCarriers": 100,
   "comparison": {

package/data/detection-golden.json

@@ -82237,6 +82237,78 @@
       "tracx-logis"
     ]
   },
+  {
+    "input": "QSP184265966",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP198482732",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP202668109",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP205361135",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP210201535",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP212901660",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP216440445",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP220318030",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
+  {
+    "input": "QSP222954533",
+    "carrier": "tracx-logis",
+    "confidence": "high",
+    "candidates": [
+      "tracx-logis"
+    ]
+  },
   {
     "input": "QUL-DL-9194640",
     "carrier": "unknown",

package/dist/browser/scraper.js

@@ -21388,7 +21388,8 @@ var Re = {
 		timezone: "Asia/Singapore",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "tracx-logis",
+			recognitionRank: 777
 		},
 		canaryUrl: "https://www.tracxlogis.com/tracking",
 		trackingUrlTemplate: "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}",
@@ -29478,6 +29479,7 @@ var _l = {
 	torrestir: 866,
 	"total-express": 975,
 	trackon: 821,
+	"tracx-logis": 777,
 	transaher: 852,
 	transcorp: 787,
 	tsjy: 992,

package/dist/carriers/tracx-logis/action.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The id of the server action TracX Logis's tracking page calls for a parcel's
+ * history, read from the page's client chunks. Next builds the page's
+ * reference with `createServerReference("<id>", …, "getTrackingHistory")`:
+ * only an id bound to that name counts, since the same module registers the
+ * page's other actions next to it.
+ */
+/** Chunks read per discovery, the last ones the tracking view loads first. */
+export declare const MAX_CHUNKS = 8;
+/** Fetches a chunk's text within the bytes it may have. */
+export type ChunkReader = (url: string) => Promise<string>;
+/**
+ * The chunks the tracking view loads, in the page's order; when the page no
+ * longer names the view, every chunk its scripts load, except the
+ * polyfills older browsers take instead.
+ */
+export declare function viewChunks(html: string, page: string): string[];
+/** The id a chunk binds to the history lookup, if it builds that reference. */
+export declare function lookupActionId(source: string): string | undefined;
+/**
+ * The action id the page's chunks bind to the history lookup. The view's own
+ * code comes after the shared chunks it loads, so the chunks are read from the
+ * last one back, one at a time, and never more than `MAX_CHUNKS`.
+ */
+export declare function discoverActionId(html: string, page: string, read: ChunkReader): Promise<string | undefined>;

package/dist/carriers/tracx-logis/action.js

@@ -0,0 +1,61 @@
+/**
+ * The id of the server action TracX Logis's tracking page calls for a parcel's
+ * history, read from the page's client chunks. Next builds the page's
+ * reference with `createServerReference("<id>", …, "getTrackingHistory")`:
+ * only an id bound to that name counts, since the same module registers the
+ * page's other actions next to it.
+ */
+/** Chunks read per discovery, the last ones the tracking view loads first. */
+export const MAX_CHUNKS = 8;
+const SCRIPT = /<script\b([^>]*)>/gi;
+const SOURCE = /\bsrc\s*=\s*["']([^"'<>]+)["']/i;
+const CHUNK_PATH = /\/_next\/static\/chunks\/[\w.-]+\.js/g;
+// The tracking view's client module, with the chunks it loads, in the page's own server components.
+const VIEW = /I\[\d+,\[([^\]]{0,8000})\],\\*"TrackingContent\\*"\]/;
+// The page streams its server components in pieces, which can split a row.
+const PIECE_BREAK = /"\]\)<\/script><script\b[^>]*>self\.__next_f\.push\(\[1,"/g;
+const LOOKUP = /createServerReference\)\(\s*"([0-9a-f]{40,42})"\s*,[\w$.\s,]{0,200}?,\s*"getTrackingHistory"\s*\)/;
+/**
+ * The chunks the tracking view loads, in the page's order; when the page no
+ * longer names the view, every chunk its scripts load, except the
+ * polyfills older browsers take instead.
+ */
+export function viewChunks(html, page) {
+    const origin = new URL(page).origin;
+    const listed = VIEW.exec(html.replace(PIECE_BREAK, ''))?.[1];
+    const paths = listed !== undefined ? [...listed.matchAll(CHUNK_PATH)].map(([path]) => path)
+        : [...html.matchAll(SCRIPT)].map(([, attributes = '']) => attributes).filter(attributes => !/\bnomodule\b/i.test(attributes))
+            .flatMap(attributes => SOURCE.exec(attributes)?.[1] ?? []);
+    const chunks = [];
+    for (const path of paths) {
+        let url;
+        try {
+            url = new URL(path.replace(/&amp;/g, '&'), page);
+        }
+        catch {
+            continue;
+        }
+        if (url.origin !== origin || !/^\/_next\/static\/chunks\/[\w.-]+\.js$/.test(url.pathname))
+            continue;
+        if (!chunks.includes(url.href))
+            chunks.push(url.href);
+    }
+    return chunks;
+}
+/** The id a chunk binds to the history lookup, if it builds that reference. */
+export function lookupActionId(source) {
+    return LOOKUP.exec(source)?.[1];
+}
+/**
+ * The action id the page's chunks bind to the history lookup. The view's own
+ * code comes after the shared chunks it loads, so the chunks are read from the
+ * last one back, one at a time, and never more than `MAX_CHUNKS`.
+ */
+export async function discoverActionId(html, page, read) {
+    for (const chunk of viewChunks(html, page).reverse().slice(0, MAX_CHUNKS)) {
+        const found = lookupActionId(await read(chunk));
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}

package/dist/carriers/tracx-logis/adapter.d.ts

@@ -0,0 +1,28 @@
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+/** The tracking page, whose server actions look a parcel up. */
+export declare const TRACX_PAGE = "https://www.tracxlogis.com/tracking";
+/**
+ * The id of the page's `getTrackingHistory` action, tried first. Every
+ * visitor's page carries the same one until the site is built again; when the
+ * tracker no longer knows it, the lookup reads the current one from the page.
+ */
+export declare const TRACX_ACTION = "406dae20d6d6ebbae5417f417519605f84915781b6";
+export declare class TracxTracker {
+    private readonly options;
+    private discovered;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+        /** The id tried first when none read from the page is current; the built-in one by default. */
+        action?: string;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+    private remember;
+    private post;
+    /** The page or one of its chunks, as text. */
+    private get;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/tracx-logis/adapter.js

@@ -0,0 +1,127 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { 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 { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
+import { discoverActionId } from './action.js';
+import { isChallengePage, normalizeTracxNumber, parseTracx, PROVIDER, readActionReply, TRACX_MAX_BYTES, UnknownActionError } from './parser.js';
+/** The tracking page, whose server actions look a parcel up. */
+export const TRACX_PAGE = 'https://www.tracxlogis.com/tracking';
+/**
+ * The id of the page's `getTrackingHistory` action, tried first. Every
+ * visitor's page carries the same one until the site is built again; when the
+ * tracker no longer knows it, the lookup reads the current one from the page.
+ */
+export const TRACX_ACTION = '406dae20d6d6ebbae5417f417519605f84915781b6';
+// The page is about a hundred kilobytes, and each of its chunks under a hundred.
+const PAGE_MAX_BYTES = 600_000;
+const CHUNK_MAX_BYTES = 600_000;
+/** How long an id read from the page stays the first try after it last answered. */
+const ACTION_TTL_MS = 6 * 3_600_000;
+const REDIRECTS = [301, 302, 303, 307, 308];
+const UNAVAILABLE = [405, 410];
+const NOT_FOUND = 404;
+export class TracxTracker {
+    options;
+    // An id the page named and the tracker then answered, for the lookups after it.
+    discovered;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeTracxNumber(raw);
+        const cached = this.discovered && this.discovered.until > Date.now() ? this.discovered.id : undefined;
+        let action = cached ?? this.options.action ?? TRACX_ACTION;
+        let stale = false;
+        const refresh = async (signal, deadline) => {
+            const html = await this.get(TRACX_PAGE, signal, deadline, PAGE_MAX_BYTES);
+            const found = await discoverActionId(html, TRACX_PAGE, url => this.get(url, signal, deadline, CHUNK_MAX_BYTES));
+            if (found === undefined)
+                throw new SchemaError(PROVIDER, 'TracX Logis tracking page no longer names its lookup: the tracking lookup changed');
+            // The page naming the id that just failed means the id is not what changed.
+            if (found === action)
+                throw new SchemaError(PROVIDER, 'TracX Logis did not answer its own lookup: the tracking lookup changed');
+            action = found;
+            stale = false;
+        };
+        const attempt = async (signal, timeoutMs) => {
+            const deadline = performance.now() + timeoutMs;
+            if (stale)
+                await refresh(signal, deadline);
+            const id = action;
+            try {
+                const result = await this.post(number, id, signal, deadline);
+                this.remember(id);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof NotFoundError)
+                    this.remember(id);
+                if (error instanceof UnknownActionError) {
+                    stale = true;
+                    if (id === cached)
+                        this.discovered = undefined;
+                }
+                throw error;
+            }
+        };
+        // The first try gets half of the budget, so a retry fits in the rest. An
+        // action the tracker no longer has is read again from the page and tried
+        // once more; a lookup that fails to reach TracX Logis, or hangs, gets one retry.
+        return runSteps({ carrier: 'tracx-logis', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [
+            { id: 'direct', run: ({ signal, remainingMs }) => attempt(signal, firstAttemptMs(remainingMs)) },
+            { id: 'action', recovers: error => error instanceof UnknownActionError,
+                run: ({ signal, remainingMs }) => attempt(signal, firstAttemptMs(remainingMs)) },
+            networkRetryStep(({ signal, remainingMs }) => attempt(signal, remainingMs)),
+        ]);
+    }
+    remember(id) {
+        if (id !== TRACX_ACTION)
+            this.discovered = { id, until: Date.now() + ACTION_TTL_MS };
+    }
+    async post(number, action, signal, deadline) {
+        // The page calls its action with the number typed in, as a one-item argument list.
+        const { response, bytes } = await fetchBounded(TRACX_PAGE, { method: 'POST', signal, headers: {
+                Accept: 'text/x-component', 'Content-Type': 'text/plain;charset=UTF-8', 'Next-Action': action,
+                'User-Agent': userAgentOf(this.options.userAgent),
+            }, body: JSON.stringify([number]) }, { provider: PROVIDER, timeoutMs: timeLeft(deadline), maxBytes: TRACX_MAX_BYTES,
+            redirect: 'manual', fetcher: this.options.fetcher, allowHttpStatuses: [...REDIRECTS, 403, NOT_FOUND, ...UNAVAILABLE] });
+        // Next answers an action it does not have with 404 and this header.
+        if (response.headers.has('x-nextjs-action-not-found'))
+            throw new UnknownActionError();
+        if (response.status === 403) {
+            if (isChallengePage(decodeText(bytes)))
+                throw new ChallengeError(PROVIDER, 'TracX Logis answered with a browser check');
+            throw new ChallengeError(PROVIDER, 'TracX Logis refused the lookup', { status: 403 });
+        }
+        if (REDIRECTS.includes(response.status) || response.status === NOT_FOUND || UNAVAILABLE.includes(response.status)) {
+            throw new TransportError(PROVIDER, 'TracX Logis tracking lookup is unavailable', { status: response.status });
+        }
+        return parseTracx(readActionReply(bytes, response.headers.get('content-type')), number);
+    }
+    /** The page or one of its chunks, as text. */
+    async get(url, signal, deadline, maxBytes) {
+        const { response, bytes } = await fetchBounded(url, { method: 'GET', signal, headers: {
+                Accept: url.endsWith('.js') ? '*/*' : 'text/html', 'User-Agent': userAgentOf(this.options.userAgent),
+            } }, { provider: PROVIDER, timeoutMs: timeLeft(deadline), maxBytes, redirect: 'manual', fetcher: this.options.fetcher,
+            allowHttpStatuses: [...REDIRECTS, 403, NOT_FOUND, ...UNAVAILABLE] });
+        const text = decodeText(bytes);
+        if (response.status === 403 || (/^\s*</.test(text) && isChallengePage(text))) {
+            throw new ChallengeError(PROVIDER, 'TracX Logis answered its tracking page with a browser check');
+        }
+        if (response.status !== 200)
+            throw new TransportError(PROVIDER, 'TracX Logis tracking page is unavailable', { status: response.status });
+        return text;
+    }
+}
+const timeLeft = (deadline) => Math.max(1, Math.floor(deadline - performance.now()));
+export const adapter = (environment) => {
+    const tracker = new TracxTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
+    return {
+        id: 'tracx-logis', recordsSteps: true, steps: ['direct', 'action', 'retry'],
+        track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeTracxNumber(number))),
+    };
+};

package/dist/carriers/tracx-logis/carrier.json

@@ -23,18 +23,72 @@
   "timezone": "Asia/Singapore",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "tracx-logis",
+    "steps": [
+      "direct",
+      "action",
+      "retry"
+    ],
+    "recognition": {
+      "rank": 777
+    }
   },
-  "capabilities": [],
+  "capabilities": [
+    "history",
+    "location",
+    "provider_code",
+    "offset_timestamps",
+    "delivered_at",
+    "destination_country",
+    "delivery_partner",
+    "delivery_tracking_number"
+  ],
   "portal": {
     "url": "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}",
     "searchUrl": "https://www.tracxlogis.com/tracking",
     "canaryUrl": "https://www.tracxlogis.com/tracking",
-    "shows": [],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "provider_code",
+      "offset_timestamps",
+      "delivered_at",
+      "progress_rail",
+      "origin_country",
+      "destination_country",
+      "delivery_partner",
+      "delivery_tracking_number",
+      "customer_reference",
+      "recipient_name",
+      "remarks"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "provider_code",
+      "offset_timestamps",
+      "delivered_at",
+      "destination_country",
+      "delivery_partner",
+      "delivery_tracking_number"
+    ],
+    "discarded": [
+      "progress_rail",
+      "origin_country",
+      "customer_reference",
+      "recipient_name",
+      "remarks"
+    ],
+    "unavailable": [
+      "eta",
+      "weight",
+      "service_name",
+      "sender_name",
+      "recipient_address",
+      "proof_of_delivery"
+    ]
   },
   "links": [
     {

package/dist/carriers/tracx-logis/numbers.json

@@ -96,6 +96,177 @@
       },
       "note": "An archived lookup on Qxpress's own tracker address; the capture was not opened, and the page loads the history by script, so the history was not visible."
     },
+    {
+      "number": "QSP222954533",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.parcelpanel.com/couriers/qxpress/",
+        "date": "2026-10-19",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "ParcelPanel's Qxpress page offered it to try. TracX Logis's tracker answers it as a parcel within Singapore, delivered by a local courier."
+    },
+    {
+      "number": "QSP220318030",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.parcelpanel.com/couriers/qxpress/",
+        "date": "2026-10-19",
+        "dateKind": "capture",
+        "access": "indexed_excerpt"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "A search engine's copy of ParcelPanel's Qxpress page offered it to try; the page now offers another. TracX Logis's tracker answers it as a parcel from Korea that Sagawa delivered in Japan, naming Sagawa's number."
+    },
+    {
+      "number": "QSP216440445",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20260416141813/https://www.parcelpanel.com/couriers/qxpress/",
+        "date": "2026-04-16",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "ParcelPanel's Qxpress page offered it to try. TracX Logis's tracker answers it as a parcel within Singapore, delivered."
+    },
+    {
+      "number": "QSP212901660",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20260120181926/https://www.parcelpanel.com/couriers/qxpress/",
+        "date": "2026-01-20",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "ParcelPanel's Qxpress page offered it to try. TracX Logis's tracker answers it as a parcel from Korea that Ecohai delivered in Japan, with Ecohai's linehaul scans."
+    },
+    {
+      "number": "QSP210201535",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20251013085950/https://www.parcelpanel.com/couriers/qxpress/",
+        "date": "2025-10-13",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "ParcelPanel's Qxpress page offered it to try. TracX Logis's tracker answers it as a parcel within Singapore, delivered."
+    },
+    {
+      "number": "QSP202668109",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.ordertracker.com/carriers/qxpress",
+        "date": "2026-10-19",
+        "dateKind": "capture",
+        "access": "full_page"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "OrderTracker's Qxpress page gives it as an example. TracX Logis's tracker answers it as a parcel within Singapore, delivered the day after a failed delivery."
+    },
+    {
+      "number": "QSP205361135",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.qxpress.net/Customer/PopupTraceParcels?TrackingNo=QSP205361135",
+        "date": "2026-10-19",
+        "dateKind": "capture",
+        "access": "indexed_excerpt"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "A lookup on Qxpress's own tracker address in a search engine's index. TracX Logis's tracker answers it as a parcel from Korea that Japan Post delivered, naming Japan Post's number."
+    },
+    {
+      "number": "QSP198482732",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20250426094317/https://www.qxpress.net/Customer/PopupTraceParcels?TrackingNo=QSP198482732Qxpress%E3%81%AB%E3%81%AA%E3%82%8A%E3%81%BE%E3%81%97%E3%81%9F%E3%82%89%E3%80%81%E6%AD%A3%E3%81%97%E3%81%84%E9%80%81%E3%82%8A%E5%85%88%E3%81%94%E4%BD%8F%E6%89%80%E3%81%AE%E3%81%94%E6%95%99%E7%A4%BA%E3%82%92%E3%81%8A%E9%A1%98%E3%81%84%E3%81%84%E3%81%9F%E3%81%97%E3%81%BE%E3%81%99%EF%BC%BE%EF%BC%BE",
+        "date": "2025-04-26",
+        "dateKind": "capture",
+        "access": "indexed_excerpt"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "An archived lookup on Qxpress's own tracker address, with a seller's note asking for the right address after the number. TracX Logis's tracker answers it as a parcel from Korea for Sagawa that failed delivery, went to long-term storage for a wrong address and was returned."
+    },
+    {
+      "number": "QSP184265966",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20250506001341/https://smartship.qxpress.net/Customer/PopupTraceParcels?TrackingNo=QSP184265966",
+        "date": "2025-05-06",
+        "dateKind": "capture",
+        "access": "indexed_excerpt"
+      },
+      "context": {
+        "assessment": "confirmed"
+      },
+      "expect": {
+        "carrier": "tracx-logis",
+        "confidence": "high"
+      },
+      "note": "An archived lookup on Qxpress's seller tracker address. TracX Logis's tracker answers it as a parcel from Korea for JD Sagawa, with only its order record from the older system."
+    },
     {
       "number": "JP3564644",
       "role": "shipment",

package/dist/carriers/tracx-logis/parser.d.ts

@@ -0,0 +1,38 @@
+import { SchemaError } from '../../core/errors/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "TracX Logis";
+export declare const TRACX_MAX_BYTES = 1000000;
+/**
+ * The tracker no longer has the action the request named: it answered with
+ * Next's reply for an unknown action, or with its page.
+ */
+export declare class UnknownActionError extends SchemaError {
+    constructor();
+}
+/** Whether a page is a CDN's or firewall's browser check. */
+export declare function isChallengePage(html: string): boolean;
+/** TracX Logis's own numbers, QSP and nine digits, as its tracker prints them; anything else is not one it issues. */
+export declare function normalizeTracxNumber(raw: string): string;
+/**
+ * What the page's server action returned. Row 0 names the row that holds it,
+ * as `{"a":"$@1",…}`; a thrown action leaves an error row there instead. The
+ * result is plain JSON whose strings Flight escapes: `$$` for a leading
+ * dollar, `$undefined` for an absent value, and a text row for a long string.
+ */
+export declare function actionResult(bytes: Uint8Array): unknown;
+/**
+ * The action's reply as the transport read it: a Flight stream, or a page in
+ * its place. A page is a browser check, or Next's answer to an action it no
+ * longer has.
+ */
+export declare function readActionReply(bytes: Uint8Array, contentType: string | null): unknown;
+/**
+ * The result of the tracking page's `getTrackingHistory` action for one
+ * number: `dataInfo`, the parcel's summary, and `history`, its scans. A
+ * number the tracker does not know comes back with every summary field null
+ * and no scans. The tracker also finds a parcel by its last-mile or delivery
+ * number, so the parcel counts only when its own number is the one asked.
+ * The recipient's name, the order's reference, the courier in charge of each
+ * scan and a scan's details, flight times in several local clocks, are left out.
+ */
+export declare function parseTracx(payload: unknown, raw: string): CarrierResult;

package/dist/carriers/tracx-logis/parser.js

@@ -0,0 +1,285 @@
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { ChallengeError, IndeterminateError, InvalidInputError, NoHistoryError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { languageStageStatus } from '../../core/status/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { tracxHandoff } from './partners.js';
+import { tracxStage } from './status.js';
+export const PROVIDER = 'TracX Logis';
+// The action's reply re-renders the tracking page with its result: under a hundred kilobytes.
+export const TRACX_MAX_BYTES = 1_000_000;
+const NUMBER = /^QSP\d{9}$/;
+const MAX_SCANS = 500;
+const MAX_EVENTS = 100;
+const INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?Z$/;
+// Bot checks a CDN or firewall could put in place of the reply.
+const CHALLENGE = /<title>\s*(?:Just a moment|Attention Required|Access Denied|Request Rejected)|_cf_chl_opt|cf-turnstile|challenge-platform|awswaf|captcha/i;
+/** Next's notFound() and redirect() travel as error rows, and mean the route changed. */
+const NEXT_CONTROL = /^(?:NEXT_NOT_FOUND$|NEXT_HTTP_ERROR_FALLBACK;|NEXT_REDIRECT;)/;
+// The fields of the parcel's summary; every one is null for a number the tracker does not know.
+const SUMMARY_FIELDS = ['ShippingNo', 'DeliveryNo', 'TrackingNo', 'InputNo', 'LastmileShippingCompany', 'StartNationCd', 'DeliveryNationCd'];
+/**
+ * The tracker no longer has the action the request named: it answered with
+ * Next's reply for an unknown action, or with its page.
+ */
+export class UnknownActionError extends SchemaError {
+    constructor() {
+        super(PROVIDER, 'TracX Logis no longer knows the action asked: the tracking lookup changed');
+        this.name = 'UnknownActionError';
+    }
+}
+/** Whether a page is a CDN's or firewall's browser check. */
+export function isChallengePage(html) {
+    return CHALLENGE.test(html.slice(0, 64_000));
+}
+/** TracX Logis's own numbers, QSP and nine digits, as its tracker prints them; anything else is not one it issues. */
+export function normalizeTracxNumber(raw) {
+    const number = raw.length <= 64 ? normalizeTrackingNumber(raw) : '';
+    if (!NUMBER.test(number))
+        throw new InvalidInputError(PROVIDER, 'TracX Logis numbers are QSP and nine digits');
+    return number;
+}
+// Row tags whose payload gives its length in bytes, as hex before a comma, and
+// ends without a line feed: text, and typed arrays.
+const LENGTH_TAGS = new Set([...'TAOoUSsLlGgMmV'].map(tag => tag.charCodeAt(0)));
+const COLON = 0x3a;
+const COMMA = 0x2c;
+const LINE_FEED = 0x0a;
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+const ascii = (bytes) => String.fromCharCode(...bytes);
+function decode(bytes) {
+    try {
+        return utf8.decode(bytes);
+    }
+    catch (cause) {
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an unreadable reply', { cause });
+    }
+}
+/** The digest of an error row; an unreadable one is an empty digest, never a Next signal. */
+function errorDigest(json) {
+    try {
+        const error = JSON.parse(json);
+        return isRecord(error) && typeof error.digest === 'string' ? error.digest : '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * The rows of a React Server Components reply by id. A text row ends where its
+ * byte length does, so rows are read by length, not split at line feeds. Hint
+ * and module rows are skipped.
+ */
+function flightRows(bytes) {
+    const rows = new Map();
+    let at = 0;
+    while (at < bytes.length) {
+        if (bytes[at] === LINE_FEED) {
+            at += 1;
+            continue;
+        }
+        const colon = bytes.indexOf(COLON, at);
+        const id = colon < 0 ? '' : ascii(bytes.subarray(at, Math.min(colon, at + 9)));
+        // Hint rows (`:HL[…]`) have no id.
+        if (id !== '' && !/^[0-9a-f]{1,8}$/.test(id))
+            throw new SchemaError(PROVIDER, 'TracX Logis returned an unreadable reply');
+        if (colon < 0)
+            throw new SchemaError(PROVIDER, 'TracX Logis returned an unreadable reply');
+        at = colon + 1;
+        if (id !== '' && LENGTH_TAGS.has(bytes[at])) {
+            const comma = bytes.indexOf(COMMA, at);
+            const length = comma < 0 ? '' : ascii(bytes.subarray(at + 1, Math.min(comma, at + 10)));
+            if (!/^[0-9a-f]{1,8}$/.test(length))
+                throw new SchemaError(PROVIDER, 'TracX Logis returned an unreadable reply');
+            const end = comma + 1 + parseInt(length, 16);
+            if (end > bytes.length)
+                throw new SchemaError(PROVIDER, 'TracX Logis returned a truncated reply');
+            if (bytes[at] === 0x54)
+                rows.set(id, { kind: 'text', text: decode(bytes.subarray(comma + 1, end)) });
+            at = end;
+            continue;
+        }
+        const end = bytes.indexOf(LINE_FEED, at);
+        const stop = end < 0 ? bytes.length : end;
+        const row = decode(bytes.subarray(at, stop));
+        at = stop + 1;
+        if (id === '')
+            continue;
+        if (row.startsWith('E{'))
+            rows.set(id, { kind: 'error', digest: errorDigest(row.slice(1)) });
+        else if (/^(?:[[{"\d-]|null$|true$|false$)/.test(row))
+            rows.set(id, { kind: 'json', json: row });
+    }
+    return rows;
+}
+function parsedRow(row) {
+    if (row?.kind !== 'json')
+        return undefined;
+    try {
+        return JSON.parse(row.json);
+    }
+    catch (cause) {
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an unreadable reply', { cause });
+    }
+}
+/**
+ * What the page's server action returned. Row 0 names the row that holds it,
+ * as `{"a":"$@1",…}`; a thrown action leaves an error row there instead. The
+ * result is plain JSON whose strings Flight escapes: `$$` for a leading
+ * dollar, `$undefined` for an absent value, and a text row for a long string.
+ */
+export function actionResult(bytes) {
+    const rows = flightRows(bytes);
+    const head = parsedRow(rows.get('0'));
+    const pointer = isRecord(head) ? head.a : Array.isArray(head) ? head[0] : undefined;
+    const target = typeof pointer === 'string' ? /^\$@([0-9a-f]{1,8})$/.exec(pointer)?.[1] : undefined;
+    if (target === undefined)
+        throw new SchemaError(PROVIDER, 'TracX Logis returned a reply without its lookup result');
+    const found = rows.get(target);
+    if (found?.kind === 'error') {
+        if (NEXT_CONTROL.test(found.digest))
+            throw new SchemaError(PROVIDER, 'TracX Logis redirected or dropped its tracking page');
+        throw new IndeterminateError(PROVIDER, 'TracX Logis could not complete the lookup');
+    }
+    if (found?.kind !== 'json')
+        throw new SchemaError(PROVIDER, 'TracX Logis returned a reply without its lookup result');
+    let nodes = 0;
+    const resolve = (node, depth) => {
+        nodes += 1;
+        if (nodes > 50_000 || depth > 16)
+            throw new SchemaError(PROVIDER, 'TracX Logis returned an oversized reply');
+        if (typeof node === 'string') {
+            if (!node.startsWith('$'))
+                return node;
+            if (node.startsWith('$$'))
+                return node.slice(1);
+            if (node === '$undefined')
+                return undefined;
+            const text = rows.get(/^\$([0-9a-f]{1,8})$/.exec(node)?.[1] ?? '');
+            if (text?.kind === 'text')
+                return text.text;
+            // A Date, a reference to an object or any other Flight value is not what this lookup returns.
+            throw new SchemaError(PROVIDER, 'TracX Logis returned an unexpected value');
+        }
+        if (Array.isArray(node))
+            return node.map((child) => resolve(child, depth + 1));
+        if (isRecord(node))
+            return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, resolve(child, depth + 1)]));
+        return node;
+    };
+    return resolve(parsedRow(found), 0);
+}
+/**
+ * The action's reply as the transport read it: a Flight stream, or a page in
+ * its place. A page is a browser check, or Next's answer to an action it no
+ * longer has.
+ */
+export function readActionReply(bytes, contentType) {
+    if (!/^text\/x-component\b/i.test(contentType ?? '')) {
+        const head = decode(bytes.subarray(0, 64_000));
+        if (isChallengePage(head))
+            throw new ChallengeError(PROVIDER, 'TracX Logis answered with a browser check');
+        if (/^\s*</.test(head))
+            throw new UnknownActionError();
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an unexpected reply');
+    }
+    return actionResult(bytes);
+}
+/** An optional text field; anything but a string is a changed reply. */
+function text(record, key, maxLength = 300) {
+    const value = record[key];
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'string')
+        throw new SchemaError(PROVIDER, `TracX Logis returned an invalid ${key}`);
+    return clean(value, maxLength);
+}
+/** Markup the page renders in a scan's note, as plain text. */
+function plain(html) {
+    return clean(html.replace(/<br\s*\/?>/gi, '. ').replace(/<[^>]*>/g, ' ')
+        .replace(/&nbsp;/gi, ' ').replace(/&amp;/gi, '&').replace(/&lt;/gi, '<').replace(/&gt;/gi, '>').replace(/&quot;/gi, '"').replace(/&#39;/g, "'"))
+        .replace(/(?:\s*\.)+\s*$/, '').replace(/\s*\.\s*\.\s*/g, '. ');
+}
+function projectScan(row) {
+    const code = text(row, 'Status', 16).toUpperCase();
+    const reason = text(row, 'Reason', 16).toUpperCase();
+    const wording = text(row, 'StatusDesc');
+    if (!wording)
+        throw new SchemaError(PROVIDER, 'TracX Logis returned a scan without wording');
+    const why = plain(text(row, 'ReasonDesc', 500));
+    const description = why && why.toLowerCase() !== wording.toLowerCase() ? `${wording}: ${why}` : wording;
+    const stamp = text(row, 'UTCDate', 40);
+    const instant = INSTANT.test(stamp) ? explicitOffsetTime(stamp) : null;
+    if (!instant)
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an invalid scan time');
+    const location = text(row, 'Location', 120);
+    const providerCode = code && reason ? `${code}:${reason}` : code;
+    const staged = tracxStage(providerCode, wording);
+    const event = {
+        time: instant.iso,
+        description,
+        ...(location ? { location } : {}),
+        ...(providerCode ? { provider_code: providerCode } : {}),
+        ...(staged ? { stage: staged.stage, stage_source: staged.source } : {}),
+    };
+    return { key: JSON.stringify([instant.timestamp, providerCode, description, location]), timestamp: instant.timestamp, event };
+}
+/**
+ * The result of the tracking page's `getTrackingHistory` action for one
+ * number: `dataInfo`, the parcel's summary, and `history`, its scans. A
+ * number the tracker does not know comes back with every summary field null
+ * and no scans. The tracker also finds a parcel by its last-mile or delivery
+ * number, so the parcel counts only when its own number is the one asked.
+ * The recipient's name, the order's reference, the courier in charge of each
+ * scan and a scan's details, flight times in several local clocks, are left out.
+ */
+export function parseTracx(payload, raw) {
+    const number = normalizeTracxNumber(raw);
+    if (!isRecord(payload) || !isRecord(payload.dataInfo) || !Array.isArray(payload.history)) {
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an invalid envelope');
+    }
+    const summary = payload.dataInfo;
+    const rows = payload.history;
+    if (rows.length === 0 && SUMMARY_FIELDS.every(key => summary[key] === null))
+        throw new NotFoundError(PROVIDER);
+    const shipping = text(summary, 'ShippingNo', 64);
+    if (!shipping)
+        throw new SchemaError(PROVIDER, 'TracX Logis returned a parcel without its number');
+    if (normalizeTrackingNumber(shipping) !== number)
+        throw new IndeterminateError(PROVIDER, 'TracX Logis answered for another parcel');
+    if (rows.length > MAX_SCANS)
+        throw new SchemaError(PROVIDER, 'TracX Logis returned an oversized history');
+    const seen = new Set();
+    const scans = [];
+    for (const row of rows) {
+        if (!isRecord(row))
+            throw new SchemaError(PROVIDER, 'TracX Logis returned an invalid scan');
+        const scan = projectScan(row);
+        if (seen.has(scan.key))
+            continue;
+        seen.add(scan.key);
+        scans.push(scan);
+    }
+    if (!scans.length)
+        throw new NoHistoryError(PROVIDER);
+    // Newest first, as the page lists them; scans at one instant keep the reply's order.
+    const events = scans.map((scan, index) => ({ ...scan, index }))
+        .sort((left, right) => right.timestamp - left.timestamp || left.index - right.index).map(scan => scan.event);
+    const newest = events[0];
+    const staged = events.find(event => event.stage);
+    const stage = staged?.stage;
+    const destination = text(summary, 'DeliveryNationCd', 8).toUpperCase();
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: staged.stage_source ?? 'carrier_map' } : {}),
+        last_status_text: newest.description,
+        last_update: newest.time,
+        expected_delivery: null,
+        ...(stage === 'delivered' ? { delivered_at: staged.time } : {}),
+        ...(/^[A-Z]{2}$/.test(destination) ? { destination_country: destination } : {}),
+        ...tracxHandoff(text(summary, 'LastmileShippingCompany', 80), text(summary, 'TrackingNo', 64), number),
+        events: events.slice(0, MAX_EVENTS),
+        ...(events.length > MAX_EVENTS ? { history_truncated: true } : {}),
+    };
+}

package/dist/carriers/tracx-logis/partners.d.ts

@@ -0,0 +1,6 @@
+import type { CarrierResult } from '../../core/result/index.js';
+/**
+ * The delivering company's number from the summary's `TrackingNo`, and that
+ * company when its name is one above and its rules fit the number.
+ */
+export declare function tracxHandoff(company: string, reference: string, number: string): Pick<CarrierResult, 'delivery_carrier' | 'delivery_tracking_number'>;

package/dist/carriers/tracx-logis/partners.js

@@ -0,0 +1,36 @@
+import { detectCarrierMatch, normalizeTrackingNumber } from '../../core/detection/index.js';
+/**
+ * The last-mile companies whose catalog carrier is certain, by the names
+ * TracX Logis's replies and site code give them. Other names, such as Ecohai,
+ * the Singapore couriers it hires, or K-Packet, which Korea Post carries and
+ * the destination's post delivers, name no carrier.
+ */
+const PARTNERS = {
+    SAGAWA: 'sagawa',
+    YAMATO: 'yamato',
+    JPPOST: 'japan-post',
+    'JP POST': 'japan-post',
+    EPOST: 'korea-post',
+    CJGLS: 'cj-logistics',
+    HANJIN: 'hanjin',
+    LOTTE: 'lotte-global',
+    LOGEN: 'logen',
+    ILYANG: 'ilyang-logis',
+};
+/** A company's name as the site reads it: without a two- or four-letter code before it, such as JD in JD Sagawa. */
+function partnerOf(company) {
+    const name = company.trim().toUpperCase().replace(/\s+/g, ' ');
+    return PARTNERS[name] ?? PARTNERS[/^(?:[A-Z]{4}|[A-Z]{2}) (.+)$/.exec(name)?.[1] ?? ''];
+}
+/**
+ * The delivering company's number from the summary's `TrackingNo`, and that
+ * company when its name is one above and its rules fit the number.
+ */
+export function tracxHandoff(company, reference, number) {
+    const delivery = normalizeTrackingNumber(reference);
+    if (!/^[A-Z0-9]{4,40}$/.test(delivery) || delivery === number)
+        return {};
+    const partner = partnerOf(company);
+    const fits = partner !== undefined && detectCarrierMatch(delivery).candidates.includes(partner);
+    return { ...(fits ? { delivery_carrier: partner } : {}), delivery_tracking_number: delivery };
+}

package/dist/carriers/tracx-logis/status.d.ts

@@ -0,0 +1,7 @@
+import { type ClassifiedWording, type Stage } from '../../core/status/index.js';
+import type { CarrierStatusMap } from '../../core/status/statusMap.js';
+/** The stage TracX Logis's codes give a scan code, `code` or `code:reason`. */
+export declare function tracxMappedStage(code: string): Stage | undefined;
+/** A scan's stage: its code, else the shared wording rules, else nothing. */
+export declare function tracxStage(code: string, wording: string): ClassifiedWording | null;
+export declare const statusMap: CarrierStatusMap;

package/dist/carriers/tracx-logis/status.js

@@ -0,0 +1,61 @@
+import { classifyWording } from '../../core/status/index.js';
+/**
+ * TracX Logis's scan codes: the older two-letter ones, which its own code
+ * labels, and the newer ones its tracker sends with their wording. A scan
+ * with a reason has the code `code:reason`.
+ */
+const CODES = new Map([
+    ['N1', 'registered'], // Received Shipping Order.
+    ['P0', 'registered'], // Generating the waybill.
+    ['P1', 'registered'], // Pickup requested.
+    ['P2', 'registered'], // Manifested for pickup.
+    ['PA', 'registered'], // Pickup assigned to a driver.
+    ['PS', 'registered'], // Pickup started.
+    ['RE', 'registered'], // Pickup reassigned.
+    ['P3', 'accepted'], // Pickup Done.
+    ['D2', 'in_transit'], // Received at Collection Center.
+    ['SI', 'in_transit'], // Released from Collection Center, towards the destination country.
+    ['M50', 'in_transit'], // Arrival in Destination Country.
+    ['SA', 'in_transit'],
+    ['M70', 'customs'], // Customs Clearance Initiated in Destination Country.
+    ['IC', 'customs'], // In customs.
+    ['CH', 'customs'], // Held in customs clearance.
+    ['M80', 'in_transit'], // Customs Clearance Completed in Destination Country.
+    ['AO', 'in_transit'],
+    ['AI', 'in_transit'],
+    ['L10', 'in_transit'], // Handover/Receipt Completed by Delivery Company.
+    ['L40', 'in_transit'], // Linehaul Loading (Transfer to Delivery Point).
+    ['L50', 'in_transit'], // Linehaul Unloading.
+    ['L70', 'in_transit'], // In Transit, between the delivery company's sites.
+    ['L20', 'out_for_delivery'], // Delivery Started.
+    ['L60', 'out_for_delivery'], // Departure for Delivery to Customer.
+    ['D3', 'out_for_delivery'], // Starting Delivery to Recipient.
+    ['D4', 'delivered'], // Delivery Completed.
+    ['DX', 'failed_attempt'], // Delivery Failed, sometimes with the reason.
+    ['LK', 'exception'], // Kept in the warehouse for long-term storage, with the reason.
+    ['RD', 'returned'], // On its way back to the sender.
+    ['RT', 'returned'], // Back with the sender.
+    ['D9', 'returned'],
+]);
+/** The reason that turns a delivery round, or a delivery, into the return to the sender. */
+const RETURN_TO_ORIGIN = 'RO';
+/** The stage TracX Logis's codes give a scan code, `code` or `code:reason`. */
+export function tracxMappedStage(code) {
+    const [base = '', reason] = code.trim().toUpperCase().split(':');
+    const stage = CODES.get(base);
+    if (reason === RETURN_TO_ORIGIN && (stage === 'out_for_delivery' || stage === 'delivered'))
+        return 'returned';
+    return stage;
+}
+/** A scan's stage: its code, else the shared wording rules, else nothing. */
+export function tracxStage(code, wording) {
+    const mapped = tracxMappedStage(code);
+    if (mapped)
+        return { stage: mapped, source: 'carrier_map' };
+    const worded = classifyWording(wording, 'in_transit');
+    return worded.source === 'none' ? null : worded;
+}
+export const statusMap = {
+    stage: (code) => (code ? tracxMappedStage(code) : undefined),
+    gaps: [],
+};

package/dist/carriers/tracx-logis/statuses.json

@@ -1,9 +1,40 @@
 {
   "carrier": "tracx-logis",
   "entries": [
+    {"code": "N1", "wording": "Received Shipping Order", "stage": "registered", "language": "en", "confirmedBy": "live", "note": "The seller's order; a parcel moved from the older system may have only this scan."},
+    {"code": "P0", "wording": "generating waybill", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "P1", "wording": "pickup requested", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "P2", "wording": "manifested", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "PA", "wording": "pickup assigned", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "PS", "wording": "pickup start", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "RE", "wording": "pickup reassigned", "stage": "registered", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "P3", "wording": "Pickup Done", "stage": "accepted", "language": "en", "confirmedBy": "live", "note": "Collected from the seller."},
+    {"code": "D2", "wording": "Received at Collection Center", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "At TracX Logis's hub in the origin country."},
     {"code": "D2", "wording": "Arrived at the Processing Facility", "stage": "in_transit", "language": "en", "confirmedBy": "portal", "note": "Activity in an archived reply of Qxpress's tracking API; seen at the origin hub in Korea and in Hong Kong."},
+    {"code": "SI", "wording": "Released from Collection Center", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Leaving the origin hub for the destination country; its details list the flight."},
     {"code": "SI", "wording": "Parcel Departed from Sender Nation", "stage": "in_transit", "language": "en", "confirmedBy": "portal", "note": "Activity in an archived reply of Qxpress's tracking API; the parcel left the origin country."},
+    {"code": "M50", "wording": "Arrival in Destination Country", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "The older code is SA."},
     {"code": "SA", "wording": "Arrived at the Distribution Center", "stage": "in_transit", "language": "en", "confirmedBy": "portal", "note": "Activity in an archived reply of Qxpress's tracking API; the arrival at the destination country's hub."},
-    {"code": "D3", "wording": "Starting Delivery to Recipient", "stage": "out_for_delivery", "language": "en", "confirmedBy": "portal", "note": "Activity in an archived reply of Qxpress's tracking API."}
+    {"code": "M70", "wording": "Customs Clearance Initiated in Destination Country", "stage": "customs", "language": "en", "confirmedBy": "live", "note": "The older code is IC."},
+    {"code": "IC", "wording": "in customs", "stage": "customs", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "CH", "wording": "In Customs Clearance", "stage": "customs", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code, whose Korean label says held in clearance; the tracker has not shown it."},
+    {"code": "M80", "wording": "Customs Clearance Completed in Destination Country", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "The older code is AO."},
+    {"code": "L10", "wording": "Handover/Receipt Completed by Delivery Company", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "The last-mile company took the parcel; the older code is AI."},
+    {"code": "L40", "wording": "Linehaul Loading (Transfer to Delivery Point)", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Seen with Ecohai and Japan Post, at the delivery company's sites."},
+    {"code": "L50", "wording": "Linehaul Unloading", "stage": "in_transit", "language": "en", "confirmedBy": "live"},
+    {"code": "L70", "wording": "In Transit", "stage": "in_transit", "language": "en", "confirmedBy": "live", "note": "Seen with Japan Post, between its sites."},
+    {"code": "L20", "wording": "Delivery Started", "stage": "out_for_delivery", "language": "en", "confirmedBy": "live", "note": "Seen with a Singapore courier; the older code is D3."},
+    {"code": "L60", "wording": "Departure for Delivery to Customer", "stage": "out_for_delivery", "language": "en", "confirmedBy": "live", "note": "Seen with Sagawa; the older code is D3."},
+    {"code": "D3", "wording": "Starting Delivery to Recipient", "stage": "out_for_delivery", "language": "en", "confirmedBy": "portal", "note": "Activity in an archived reply of Qxpress's tracking API."},
+    {"code": "D4", "wording": "Delivery Completed", "stage": "delivered", "language": "en", "confirmedBy": "live"},
+    {"code": "DX:OT", "wording": "Delivery Failed", "stage": "failed_attempt", "language": "en", "confirmedBy": "live", "note": "The reason's wording, over time, follows; another round came the next day."},
+    {"code": "DX", "wording": "Delivery Failed", "stage": "failed_attempt", "language": "en", "confirmedBy": "live", "note": "Without a reason; the parcel went to long-term storage after it."},
+    {"code": "LK:IA", "wording": "Registered for long-term storage in the TraxLogis warehouse", "stage": "exception", "language": "en", "confirmedBy": "live", "note": "The reason's wording, Wrong Address, follows; the return came the next day."},
+    {"code": "D3:RO", "wording": "rto returning", "stage": "returned", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code for a delivery round with the reason RO, return to origin; the tracker has not shown it."},
+    {"code": "D4:RO", "wording": "rto returned", "stage": "returned", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code for a delivery with the reason RO; the tracker has not shown it."},
+    {"code": "RD", "wording": "retun order on delivery", "stage": "returned", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "RT", "wording": "Return completed", "stage": "returned", "language": "en", "confirmedBy": "live", "note": "Back with the sender after long-term storage."},
+    {"code": "RT", "wording": "retun order deliverd", "stage": "returned", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."},
+    {"code": "D9", "wording": "returned", "stage": "returned", "language": "en", "confirmedBy": "source", "note": "A label in TracX Logis's own site code; the tracker has not shown it."}
   ]
 }

package/dist/core/catalog/statusMaps.js

@@ -351,6 +351,7 @@ import { statusMap as toptrans } from '../../carriers/toptrans/status.js';
 import { statusMap as torrestir } from '../../carriers/torrestir/status.js';
 import { statusMap as totalExpress } from '../../carriers/total-express/status.js';
 import { statusMap as trackon } from '../../carriers/trackon/status.js';
+import { statusMap as tracxLogis } from '../../carriers/tracx-logis/status.js';
 import { statusMap as transaher } from '../../carriers/transaher/status.js';
 import { statusMap as transcorp } from '../../carriers/transcorp/status.js';
 import { statusMap as transmission } from '../../carriers/transmission/status.js';
@@ -442,7 +443,7 @@ export const STATUS_MAPS = {
     't-cat': tCat, 't-group': tGroup, 'tanzania-posts': tanzaniaPosts, taxydema, 'tci-express': tciExpress, 'tcs-pakistan': tcsPakistan, tdn, tealca,
     'team-express-ae': teamExpressAe, 'team-global-express': teamGlobalExpress, teleship, 'tforce-freight': tforceFreight,
     'thailand-post': thailandPost, thhy, tiki, 'tmm-express': tmmExpress, tnt, 'tnt-it': tntIt, toptrans, torrestir, 'total-express': totalExpress,
-    trackon, transaher, transcorp, transmission, tsjy, 'tws-express': twsExpress, 'ubi-smart-parcel': ubiSmartParcel,
+    trackon, 'tracx-logis': tracxLogis, transaher, transcorp, transmission, tsjy, 'tws-express': twsExpress, 'ubi-smart-parcel': ubiSmartParcel,
     'united-delivery-service': unitedDeliveryService, ups, urbano, urvaam,
     'uzbekistan-post': uzbekistanPost, valmo, 'vasp-expresso': vaspExpresso, veloces, venipak, 'via-cargo': viaCargo, 'viettel-post': viettelPost,
     'vinted-go': vintedGo, wanbexpress, whistl, winit, 'xde-logistics': xdeLogistics, xdp, xlcourier, 'xpo-ltl': xpoLtl,

package/dist/data/catalog.json

@@ -28429,7 +28429,8 @@
         "timezone": "Asia/Singapore",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "tracx-logis",
+            "recognitionRank": 777
         },
         "canaryUrl": "https://www.tracxlogis.com/tracking",
         "trackingUrlTemplate": "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}",

package/dist/generated/catalog.d.ts

@@ -18106,7 +18106,8 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "Asia/Singapore";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "universal";
+            readonly adapter: "tracx-logis";
+            readonly recognitionRank: 777;
         };
         readonly canaryUrl: "https://www.tracxlogis.com/tracking";
         readonly trackingUrlTemplate: "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}";

package/dist/generated/catalog.js

@@ -28430,7 +28430,8 @@ export const CARRIER_CATALOG = {
         "timezone": "Asia/Singapore",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "tracx-logis",
+            "recognitionRank": 777
         },
         "canaryUrl": "https://www.tracxlogis.com/tracking",
         "trackingUrlTemplate": "https://www.tracxlogis.com/tracking?trackingNo={trackingNumber}",

package/dist/generated/recognition.js

@@ -307,6 +307,7 @@ export const CARRIER_RECOGNITION_RANKS = {
     "torrestir": 866,
     "total-express": 975,
     "trackon": 821,
+    "tracx-logis": 777,
     "transaher": 852,
     "transcorp": 787,
     "tsjy": 992,

package/dist/generated/registry.js

@@ -421,6 +421,7 @@ import { adapter as toptrans } from '../carriers/toptrans/adapter.js';
 import { adapter as torrestir } from '../carriers/torrestir/adapter.js';
 import { adapter as totalExpress } from '../carriers/total-express/adapter.js';
 import { adapter as trackon } from '../carriers/trackon/adapter.js';
+import { adapter as tracxLogis } from '../carriers/tracx-logis/adapter.js';
 import { adapter as transaher } from '../carriers/transaher/adapter.js';
 import { adapter as transcorp } from '../carriers/transcorp/adapter.js';
 import { adapter as transmission } from '../carriers/transmission/adapter.js';
@@ -885,6 +886,7 @@ export const REGISTRY = {
         "torrestir": torrestir,
         "total-express": totalExpress,
         "trackon": trackon,
+        "tracx-logis": tracxLogis,
         "transaher": transaher,
         "transcorp": transcorp,
         "transmission": transmission,
@@ -1627,7 +1629,7 @@ export const REGISTRY = {
         "total-express": "total-express",
         "tp-logistics-th": "universal",
         "trackon": "trackon",
-        "tracx-logis": "universal",
+        "tracx-logis": "tracx-logis",
         "trans-o-flex": "universal",
         "transaher": "transaher",
         "transcorp": "transcorp",

package/dist/server/openapi.json

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

package/package.json

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