universal-parcel-scraper 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,11 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class YtoTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/yto/adapter.js

@@ -0,0 +1,36 @@
+import { TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { normalizeYtoNumber, parseYto } from './parser.js';
+// Current domestic website request builder, queryWaybillTrackList:
+// https://www.yto.net.cn/ (Nuxt client). This endpoint accepts anonymous reads.
+const ENDPOINT = 'https://www.yto.net.cn/ec/order/gwWaybillInfoList';
+export class YtoTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeYtoNumber(raw);
+        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' }, 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;
+                    }
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new YtoTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'yto', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/yto/carrier.json

@@ -0,0 +1,75 @@
+{
+  "id": "yto",
+  "displayName": "YTO Express",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "CN"
+    ]
+  },
+  "brand": {
+    "color": "#4d148c"
+  },
+  "selectable": true,
+  "timezone": "Asia/Shanghai",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "yto",
+    "steps": [
+      "direct"
+    ],
+    "localClocks": true
+  },
+  "capabilities": [
+    "history",
+    "location"
+  ],
+  "portal": {
+    "url": "https://www.yto.net.cn/ytoExpress/waybill/search",
+    "canaryUrl": "https://www.yto.net.cn/ytoExpress/waybill/search",
+    "shows": [
+      "status",
+      "history",
+      "location"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location"
+    ],
+    "discarded": [
+      "contact_details",
+      "recipient_details",
+      "collection_addresses",
+      "signature_images",
+      "unlabelled_weight"
+    ],
+    "unavailable": [
+      "eta",
+      "pickup_point"
+    ]
+  },
+  "links": [
+    {
+      "domains": [
+        "yto.net.cn"
+      ],
+      "params": [
+        "mailNo",
+        "waybillNo"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "yto-1",
+      "pattern": "^D\\d{11}$",
+      "confidence": "high"
+    },
+    {
+      "id": "yto-2",
+      "pattern": "^YT\\d{13}$",
+      "confidence": "high"
+    }
+  ]
+}

package/dist/carriers/yto/numbers.json

@@ -0,0 +1,33 @@
+{
+  "carrier": "yto",
+  "records": [
+    {
+      "number": "D00015070907",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://gist.github.com/zxp/e83a4a1b7294a5ed6207",
+        "date": "2015-08-29"
+      },
+      "expect": {
+        "carrier": "yto",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "YT8879092508074",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.ptt.cc/bbs/e-shopping/M.1781927397.A.39F.html",
+        "date": "2026-06-20"
+      },
+      "expect": {
+        "carrier": "yto",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    }
+  ]
+}

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

@@ -0,0 +1,3 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeYtoNumber(raw: string): string;
+export declare function parseYto(payload: unknown, trackingNumber: string): CarrierResult;

package/dist/carriers/yto/parser.js

@@ -0,0 +1,92 @@
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InputRequiredError, SchemaError } from '../../core/errors/index.js';
+import { zonedTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { ytoScan, ytoStatus } from './status.js';
+const PROVIDER = 'YTO Express';
+// The domestic client's /ec/apollo/checkWaybillNo rules. Keep them local so a
+// lookup does not require a separate configuration request.
+const NUMBER = /^(?:[68]\d{17}|(?:DD|G8|99|70|71|78|79)\d{16}|M\d{14}|YT\d{13}|YT[DG]\d{12}|(?:DD|DB|JY)\d{10}|[25678GVMBCDFHZ]\d{11}|DD\d{8}|YT[HZ]\d{12}|GD6\d{9})$/;
+const ZONE = 'Asia/Shanghai';
+export function normalizeYtoNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!NUMBER.test(number))
+        throw new InputRequiredError(PROVIDER, 'number', 'YTO requires a domestic waybill number');
+    return number;
+}
+export function parseYto(payload, trackingNumber) {
+    const number = normalizeYtoNumber(trackingNumber);
+    if (!Array.isArray(payload))
+        throw new SchemaError(PROVIDER, 'YTO returned an invalid shipment list');
+    if (!payload.length)
+        throw new IndeterminateError(PROVIDER, 'YTO returned no shipment details');
+    if (payload.length !== 1 || !isRecord(payload[0]) || normalizeTrackingNumber(clean(payload[0].waybillNo, 64)) !== number) {
+        throw new SchemaError(PROVIDER, 'YTO returned missing or ambiguous shipment identity');
+    }
+    const item = payload[0];
+    // The feed can echo any well-shaped number without returning a history.
+    // This also happens for archived waybills; it proves no parcel absence.
+    if (item.waybillProcessInfo === undefined)
+        throw new IndeterminateError(PROVIDER, 'YTO returned no shipment history');
+    if (!Array.isArray(item.waybillProcessInfo) || item.waybillProcessInfo.length > 1000)
+        throw new SchemaError(PROVIDER);
+    if (!item.waybillProcessInfo.length)
+        throw new IndeterminateError(PROVIDER, 'YTO returned no shipment history');
+    const events = [];
+    let returning = false;
+    // The official client uses the first row as current. Read oldest first to
+    // preserve a return leg when later scans use ordinary movement/signature codes.
+    for (const raw of [...item.waybillProcessInfo].reverse()) {
+        if (!isRecord(raw) || normalizeTrackingNumber(clean(raw.waybillNo, 64)) !== number) {
+            throw new SchemaError(PROVIDER, 'YTO returned mixed or incomplete shipment history');
+        }
+        const code = clean(raw.opCode, 32);
+        const label = clean(raw.opName, 200);
+        if (!code || !label)
+            throw new SchemaError(PROVIDER, 'YTO returned a scan with no operation');
+        const details = clean(raw.description, 1000);
+        const returnType = clean(raw.ioTypeName, 32);
+        if (code === '835' || /^退回(?:[一二三四五六七八九十\d]+次)?$/.test(returnType)
+            || /(?:收件人|签收人)\s*[:：]\s*退回(?:[，。,]|$)/.test(details))
+            returning = true;
+        const ext = isRecord(raw.extTrack) ? raw.extTrack : {};
+        const mapped = ytoStatus(code, ext.signType);
+        const stage = returning && mapped?.stage === 'delivered' ? 'returned' : mapped?.stage;
+        const wording = ytoScan(label)?.wording ?? label;
+        const description = returning && mapped?.stage === 'delivered' ? 'Returned to the sender'
+            : returning && mapped?.stage === 'out_for_delivery' ? 'Out for delivery back to the sender'
+                : returning && mapped?.stage === 'ready_for_pickup' ? 'In a parcel locker or station on its way back' : wording;
+        const clock = clean(raw.opTime, 64);
+        const parsed = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(clock)
+            ? zonedTime(clock, 'yyyy-MM-dd HH:mm:ss', ZONE) : null;
+        const location = clean(raw.opOrgName, 200);
+        // opName is the short operation label. The website's expanded description
+        // includes courier names/phones, collection addresses and recipient details.
+        const event = { description, provider_code: code,
+            ...(parsed ? { time: parsed.iso } : clock ? { provider_time_text: clock } : {}),
+            ...(location ? { location } : {}), ...(stage ? { stage } : {}),
+            ...(returning ? { provider_leg: 'return' } : {}) };
+        events.push(event);
+    }
+    events.reverse();
+    // Remove repeated rows from newest first so an old duplicate cannot move
+    // the current scan behind a different status, especially with unresolved clocks.
+    const seen = new Set();
+    const unique = events.filter(event => {
+        const key = JSON.stringify(event);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    const latest = unique[0];
+    const rawLatest = item.waybillProcessInfo[0];
+    const mapped = ytoStatus(latest.provider_code, isRecord(rawLatest.extTrack) ? rawLatest.extTrack.signType : undefined);
+    const returned = latest.stage === 'returned';
+    return { status: returned ? 'exception' : mapped?.status ?? 'unknown',
+        ...(latest.stage ? { current_stage: latest.stage } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null, timezone: ZONE,
+        ...(mapped?.stage === 'delivered' && !returned && latest.time ? { delivered_at: latest.time } : {}),
+        events: unique.slice(0, 100) };
+}

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

@@ -0,0 +1,10 @@
+import type { ClassifiedStatus, Stage } from '../../core/status/index.js';
+/** Exact operation codes from the domestic website; unfamiliar codes stay unmapped. */
+export declare function ytoStatus(code: string, signType?: unknown): ClassifiedStatus | undefined;
+export interface YtoScan {
+    stage: Stage;
+    wording: string;
+    returnLeg?: true;
+}
+/** The stage and stored wording of one YTO scan label, Chinese or translated. */
+export declare function ytoScan(label: string): YtoScan | undefined;

package/dist/carriers/yto/status.js

@@ -0,0 +1,46 @@
+const STATUS = new Map([
+    ['123', { status: 'in_transit', stage: 'in_transit' }],
+    ['756', { status: 'in_transit', stage: 'in_transit' }],
+    ['310', { status: 'in_transit', stage: 'accepted' }],
+    ['311', { status: 'in_transit', stage: 'accepted' }],
+    ['111', { status: 'in_transit', stage: 'in_transit' }],
+    ['131', { status: 'in_transit', stage: 'in_transit' }],
+    ['171', { status: 'in_transit', stage: 'in_transit' }],
+    ['136', { status: 'in_transit', stage: 'in_transit' }],
+    ['176', { status: 'in_transit', stage: 'in_transit' }],
+    ['710', { status: 'out_for_delivery', stage: 'out_for_delivery' }],
+    ['741', { status: 'out_for_delivery', stage: 'out_for_delivery' }],
+    ['746', { status: 'out_for_delivery', stage: 'out_for_delivery' }],
+    ['745', { status: 'delivered', stage: 'delivered' }],
+    ['835', { status: 'exception', stage: 'exception' }],
+]);
+/** Exact operation codes from the domestic website; unfamiliar codes stay unmapped. */
+export function ytoStatus(code, signType) {
+    if (code === '751')
+        return signType === '1'
+            ? { status: 'in_transit', stage: 'in_transit' } : { status: 'in_transit', stage: 'ready_for_pickup' };
+    return STATUS.get(code);
+}
+const SCANS = [
+    ['揽收扫描', 'Pickup scan', 'accepted', 'Picked up'],
+    ['装件入车扫描', 'Load scan into vehicle', 'in_transit', 'Loaded for transport'],
+    ['下车扫描', 'Get off scan', 'in_transit', 'Unloaded at a sorting centre'],
+    ['快件城市信息', 'Package city information', 'in_transit', 'In transit'],
+    ['退回件扫描', 'Return package scan', 'exception', 'Return to the sender started'],
+    ['派件扫描', 'Delivery scan', 'out_for_delivery', 'Out for delivery'],
+    ['入柜|入库', 'In cabinet | In storage', 'ready_for_pickup', 'In a parcel locker or pickup station'],
+    // The courier took the parcel back out of the locker or station.
+    ['小件员取出', 'Small item handler takes out.', 'in_transit', 'Taken out of the locker by the courier'],
+    ['PDA正常签收扫描', 'PDA normal delivery scan', 'delivered', 'Delivered'],
+];
+function key(label) {
+    return label.trim().replace(/\s*\|\s*/g, '|').replace(/[.。]+$/, '').toLowerCase();
+}
+const BY_LABEL = new Map(SCANS.flatMap(([chinese, english, stage, wording]) => {
+    const entry = { stage, wording, ...(chinese === '退回件扫描' ? { returnLeg: true } : {}) };
+    return [[key(chinese), entry], [key(english), entry]];
+}));
+/** The stage and stored wording of one YTO scan label, Chinese or translated. */
+export function ytoScan(label) {
+    return BY_LABEL.get(key(label));
+}

package/dist/carriers/yto/statuses.json

@@ -0,0 +1,206 @@
+{
+  "carrier": "yto",
+  "entries": [
+    {
+      "wording": "揽收扫描",
+      "language": "zh",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Picked up\".",
+      "code": "310"
+    },
+    {
+      "wording": "Pickup scan",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 揽收扫描; stored as \"Picked up\"."
+    },
+    {
+      "wording": "装件入车扫描",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Loaded for transport\".",
+      "code": "131"
+    },
+    {
+      "wording": "Load scan into vehicle",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 装件入车扫描; stored as \"Loaded for transport\"."
+    },
+    {
+      "wording": "下车扫描",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Unloaded at a sorting centre\".",
+      "code": "171"
+    },
+    {
+      "wording": "Get off scan",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 下车扫描; stored as \"Unloaded at a sorting centre\"."
+    },
+    {
+      "wording": "快件城市信息",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"In transit\".",
+      "code": "123"
+    },
+    {
+      "wording": "Package city information",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 快件城市信息; stored as \"In transit\"."
+    },
+    {
+      "wording": "退回件扫描",
+      "language": "zh",
+      "stage": "exception",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Return to the sender started\". Later delivery-side scans are stored as the trip back to the sender.",
+      "code": "835"
+    },
+    {
+      "wording": "Return package scan",
+      "language": "en",
+      "stage": "exception",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 退回件扫描; stored as \"Return to the sender started\"."
+    },
+    {
+      "wording": "派件扫描",
+      "language": "zh",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Out for delivery\". After a return scan: \"Out for delivery back to the sender\"; the movement stage remains active.",
+      "code": "710"
+    },
+    {
+      "wording": "Delivery scan",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 派件扫描; stored as \"Out for delivery\"."
+    },
+    {
+      "wording": "入柜|入库",
+      "language": "zh",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"In a parcel locker or pickup station\". After a return scan: \"In a parcel locker or station on its way back\"; the pickup stage remains active.",
+      "code": "751"
+    },
+    {
+      "wording": "In cabinet | In storage",
+      "language": "en",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 入柜|入库; stored as \"In a parcel locker or pickup station\"."
+    },
+    {
+      "wording": "小件员取出",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Taken out of the locker by the courier\". The courier took the parcel back out of the locker or station.",
+      "code": "756"
+    },
+    {
+      "wording": "Small item handler takes out.",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of 小件员取出; stored as \"Taken out of the locker by the courier\"."
+    },
+    {
+      "wording": "PDA正常签收扫描",
+      "language": "zh",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "Relayed by ParcelsApp; stored as \"Delivered\". After a return scan it is the sender signing: \"Returned to the sender\", stage returned.",
+      "code": "745"
+    },
+    {
+      "wording": "PDA normal delivery scan",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-27",
+      "note": "ParcelsApp's translation of PDA正常签收扫描; stored as \"Delivered\"."
+    },
+    {
+      "wording": "已取件",
+      "code": "311",
+      "language": "zh",
+      "stage": "accepted",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    },
+    {
+      "wording": "运输中",
+      "code": "111",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    },
+    {
+      "wording": "运输中",
+      "code": "136",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    },
+    {
+      "wording": "运输中",
+      "code": "176",
+      "language": "zh",
+      "stage": "in_transit",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    },
+    {
+      "wording": "派件中",
+      "code": "741",
+      "language": "zh",
+      "stage": "out_for_delivery",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    },
+    {
+      "wording": "派件中",
+      "code": "746",
+      "language": "zh",
+      "stage": "out_for_delivery",
+      "confirmedBy": "documentation",
+      "note": "Exact code mapping in the official domestic website tracking client."
+    }
+  ]
+}

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

@@ -0,0 +1,11 @@
+import type { AdapterFactory, TrackingContext } from '../../core/adapter/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class YundaTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<import("../../index.js").CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/yunda/adapter.js

@@ -0,0 +1,68 @@
+import { createHash, randomBytes } from 'node:crypto';
+import makeFetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+import { ChallengeError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { solveYundaSlider } from './challenge.js';
+import { normalizeYundaNumber, parseYunda, yundaEnvelope } from './parser.js';
+const ORIGIN = 'https://web.yundaex.com';
+// Public apiSetting.js on the current consumer site signs ordinary anonymous
+// requests with MD5(SHA1(randomStr + client constant + timestamp)).
+const CLIENT_CONSTANT = '2024YdWeb';
+export class YundaTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeYundaNumber(raw);
+        return runSteps({ carrier: 'yunda', signal: context.signal, budgetMs: context.budgetMs ?? 20_000,
+            recorder: this.options.recorder ?? NOOP_RECORDER }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
+                    // A fresh, request-scoped session binds challenge generation and lookup.
+                    const sessionFetch = makeFetchCookie(this.options.fetcher ?? fetch, new CookieJar());
+                    const started = Date.now();
+                    const randomStr = randomBytes(8).toString('hex');
+                    const timeStamp = String(Date.now());
+                    const signature = createHash('md5').update(createHash('sha1').update(randomStr + CLIENT_CONSTANT + timeStamp).digest('hex')).digest('hex').toUpperCase();
+                    const params = new URLSearchParams({ wid: '22', randomStr, timeStamp, signature });
+                    const request = async (path, init = {}) => {
+                        try {
+                            const { bytes } = await fetchBounded(ORIGIN + path, { ...init, signal }, {
+                                provider: 'Yunda Express', timeoutMs: Math.max(1, Math.floor(remainingMs - (Date.now() - started))),
+                                maxBytes: 1_000_000, fetcher: sessionFetch
+                            });
+                            return parseJsonBytes(bytes, 'Yunda Express');
+                        }
+                        catch (error) {
+                            if (error instanceof UpstreamHttpError && [404, 410].includes(error.status))
+                                throw new TransportError('Yunda Express', 'Yunda tracking endpoint is unavailable', { cause: error });
+                            throw error;
+                        }
+                    };
+                    const type = yundaEnvelope(await request('/index.php/api/order.record/captcha_type?' + params));
+                    if (type.data !== 1)
+                        throw new ChallengeError('Yunda Express', 'Yunda requires an unsupported verification type');
+                    const captcha = yundaEnvelope(await request('/index.php/api/order.record/captcha?' + params));
+                    if (!isRecord(captcha.data))
+                        throw new SchemaError('Yunda Express');
+                    const coordinate = await solveYundaSlider(captcha.data, signal);
+                    signal.throwIfAborted();
+                    const body = new FormData();
+                    for (const [key, value] of params)
+                        body.append(key, value);
+                    body.append('x', String(coordinate.x));
+                    body.append('y', String(coordinate.y));
+                    body.append('tm', number);
+                    // Actual backend acceptance is required; computing a coordinate is not a
+                    // successful lookup. One submission, with no candidate/verification retry.
+                    return parseYunda(await request('/index.php/api/v2.record/search', { method: 'POST', body }), number);
+                } }]);
+    }
+}
+export const adapter = environment => {
+    const tracker = new YundaTracker({ fetcher: environment.fetcher, recorder: environment.recorder });
+    return { id: 'yunda', recordsSteps: true, steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context) };
+};