universal-parcel-scraper 0.652.3-main.3107 → 0.653.0-main.3111

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 **611 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **613 dedicated adapters** and **5 universal fallbacks**
 
 <sub>789 catalog entries · 135 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 16,475 such statuses, each filed under one stage.
+The carrier folders record 16,485 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

@@ -15150,7 +15150,8 @@
     "timezone": "Africa/Lagos",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "gig-logistics",
+      "localClocks": true
     },
     "canaryUrl": "https://giglogistics.com/track-shipment/",
     "trackingUrlTemplate": "https://giglogistics.com/track-shipment/?waybill={trackingNumber}",
@@ -26523,7 +26524,9 @@
     "timezone": "Australia/Sydney",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "sendle",
+      "recognitionRank": 64,
+      "localClocks": true
     },
     "canaryUrl": "https://www.sendle.com/",
     "trackingUrlTemplate": "https://www.sendle.com/tracking?ref={trackingNumber}",

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 789,
-  "activeAdapters": 611,
+  "activeAdapters": 613,
   "countries": 135,
   "referenceCarriers": 100,
   "comparison": {

package/data/detection-golden.json

@@ -84468,6 +84468,7 @@
       "sendle"
     ],
     "asked": [
+      "sendle",
       "colis-prive"
     ]
   },

package/dist/browser/scraper.js

@@ -11727,7 +11727,8 @@ var Ye = {
 		timezone: "Africa/Lagos",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "gig-logistics",
+			localClocks: !0
 		},
 		canaryUrl: "https://giglogistics.com/track-shipment/",
 		trackingUrlTemplate: "https://giglogistics.com/track-shipment/?waybill={trackingNumber}",
@@ -20124,7 +20125,9 @@ var Ye = {
 		timezone: "Australia/Sydney",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "sendle",
+			recognitionRank: 64,
+			localClocks: !0
 		},
 		canaryUrl: "https://www.sendle.com/",
 		trackingUrlTemplate: "https://www.sendle.com/tracking?ref={trackingNumber}",
@@ -30902,6 +30905,7 @@ var zl = {
 	seko: 854,
 	sendex: 794,
 	sending: 891,
+	sendle: 64,
 	serpost: 893,
 	servientrega: 979,
 	seur: 870,

package/dist/carriers/dhlink/status.js

@@ -89,6 +89,8 @@ const PATTERNS = [
     [/已出口直封$/, 'in_transit'],
     [/^出口海关\/放行$/, 'in_transit'],
     [/^到达寄达地(?:处理中心)?$/, 'in_transit'],
+    // Collected at the destination port after import clearance, though its English says a delivery was made.
+    [/^目的港已提货/, 'in_transit'],
     [/^离开【[^】]*】处理中心$/, 'in_transit'],
     [/^送交出口海关$/, 'customs'],
     [/安排投递$/, 'out_for_delivery'],

package/dist/carriers/dhlink/statuses.json

@@ -53,6 +53,7 @@
     {"wording": "送交出口海关", "stage": "customs", "language": "zh", "confirmedBy": "live", "note": "Presented to export customs."},
     {"wording": "出口海关/放行", "stage": "in_transit", "language": "zh", "confirmedBy": "live", "note": "Released by export customs; transit resumes."},
     {"wording": "到达寄达地", "stage": "in_transit", "language": "zh", "confirmedBy": "live", "note": "Arrived in the destination country."},
+    {"wording": "目的港已提货 Delivery has been made at the destination port", "stage": "in_transit", "language": "zh", "confirmedBy": "live", "note": "Collected at the destination port after import clearance, before the destination's own scans; the English says a delivery, which it is not."},
     {"wording": "到达寄达地处理中心", "stage": "in_transit", "language": "zh", "confirmedBy": "live", "note": "Arrived at the destination's processing centre."},
     {"wording": "离开【GB】处理中心", "stage": "in_transit", "language": "zh", "confirmedBy": "live", "note": "Left the destination's processing centre."},
     {"wording": "【GB】安排投递", "stage": "out_for_delivery", "language": "zh", "confirmedBy": "live", "note": "Out for delivery abroad; any country."},

package/dist/carriers/gig-logistics/adapter.d.ts

@@ -0,0 +1,17 @@
+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';
+/** The tracking page, which asks the lookup for the waybill in its query. */
+export declare const GIG_LOGISTICS_PAGE = "https://giglogistics.com/track-shipment/";
+/** The lookup the tracking page asks, followed by the waybill. */
+export declare const GIG_LOGISTICS_API = "https://agility.giglogistics.com/api/portal/trackshipment/";
+export declare class GigLogisticsTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/gig-logistics/adapter.js

@@ -0,0 +1,53 @@
+import { ChallengeError, 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 { GIG_LOGISTICS_MAX_BYTES, normalizeGigLogisticsNumber, parseGigLogistics, PROVIDER } from './parser.js';
+/** The tracking page, which asks the lookup for the waybill in its query. */
+export const GIG_LOGISTICS_PAGE = 'https://giglogistics.com/track-shipment/';
+/** The lookup the tracking page asks, followed by the waybill. */
+export const GIG_LOGISTICS_API = 'https://agility.giglogistics.com/api/portal/trackshipment/';
+const REDIRECTS = [301, 302, 303, 307, 308];
+// Bot checks a CDN or a firewall could put in place of the reply.
+const CHALLENGE = /_cf_chl_opt|cf-turnstile|<title>\s*Just a moment|<title>\s*Attention Required|cf-error-details|captcha/i;
+/** The reply's JSON. */
+function json(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch (cause) {
+        if (CHALLENGE.test(body.slice(0, 64_000)))
+            throw new ChallengeError(PROVIDER, 'GIG Logistics answered with a browser check', { cause });
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned a reply that is not JSON', { cause });
+    }
+}
+export class GigLogisticsTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeGigLogisticsNumber(raw);
+        const read = async (signal, timeoutMs) => {
+            const { response, bytes } = await fetchBounded(`${GIG_LOGISTICS_API}${number}`, { method: 'GET', signal, headers: {
+                    Accept: 'application/json', Referer: GIG_LOGISTICS_PAGE, 'User-Agent': userAgentOf(this.options.userAgent),
+                } }, { provider: PROVIDER, timeoutMs: Math.max(1, Math.floor(timeoutMs)), maxBytes: GIG_LOGISTICS_MAX_BYTES,
+                redirect: 'manual', fetcher: this.options.fetcher, allowHttpStatuses: [...REDIRECTS, 404, 410] });
+            // The lookup answers every waybill, known or not, with HTTP 200; a redirect or a 404 is a moved route.
+            if (response.status !== 200)
+                throw new TransportError(PROVIDER, 'GIG Logistics tracking lookup moved', { status: response.status });
+            return parseGigLogistics(json(decodeText(bytes)), number);
+        };
+        // A read that fails to reach the site, or hangs, gets one more: the first gets half of the budget.
+        return runSteps({ carrier: 'gig-logistics', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
+            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 GigLogisticsTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
+    return { id: 'gig-logistics', recordsSteps: true, steps: ['direct', 'retry'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/gig-logistics/carrier.json

@@ -18,18 +18,49 @@
   "timezone": "Africa/Lagos",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "gig-logistics",
+    "steps": [
+      "direct",
+      "retry"
+    ],
+    "localClocks": true
   },
-  "capabilities": [],
+  "capabilities": [
+    "history",
+    "location",
+    "provider_code"
+  ],
   "portal": {
     "url": "https://giglogistics.com/track-shipment/?waybill={trackingNumber}",
     "searchUrl": "https://giglogistics.com/track-shipment/",
     "canaryUrl": "https://giglogistics.com/track-shipment/",
-    "shows": [],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "shows": [
+      "status",
+      "history",
+      "origin",
+      "destination",
+      "event_details"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "provider_code"
+    ],
+    "discarded": [
+      "origin",
+      "destination",
+      "event_details",
+      "recipient_name",
+      "staff_details"
+    ],
+    "unavailable": [
+      "eta",
+      "weight",
+      "service_name",
+      "offset_timestamps",
+      "delivery_tracking_number"
+    ]
   },
   "links": [
     {

package/dist/carriers/gig-logistics/parser.d.ts

@@ -0,0 +1,21 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "GIG Logistics";
+export declare const GIG_LOGISTICS_MAX_BYTES: number;
+/**
+ * A GIG waybill, ten digits. Another reference the tracker may take as an
+ * Alphacode is left to the universal providers, without a request: its
+ * layout is undocumented and the reply could not be bound to it.
+ */
+export declare function normalizeGigLogisticsNumber(raw: string): string;
+/**
+ * The reply of the tracking page's `api/portal/trackshipment/{waybill}`
+ * lookup. A waybill it has gets `Code` "200" and its scans in
+ * `Object.MobileShipmentTrackings`, each naming its waybill, with a code and
+ * the code's fixed wording in `ScanStatus`. A waybill it does not have gets
+ * `Code` "400" and "Invalid waybill number!!". Only scans naming the whole
+ * waybill asked are read, and of them only the code, its wording, the clock
+ * and the service centre: the origin and destination addresses, the incident
+ * text the page shows, which can name the receiver, and the scanning staff
+ * are never read.
+ */
+export declare function parseGigLogistics(payload: unknown, raw: string): CarrierResult;

package/dist/carriers/gig-logistics/parser.js

@@ -0,0 +1,158 @@
+import { DateTime } from 'luxon';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { 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, cleanScalar } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { gigLogisticsCodeWording, gigLogisticsStage } from './status.js';
+export const PROVIDER = 'GIG Logistics';
+// One waybill's reply is a few kilobytes.
+export const GIG_LOGISTICS_MAX_BYTES = 512 * 1024;
+const WAYBILL = /^\d{10}$/;
+// What the tracker could take as its undocumented Alphacode.
+const OTHER_REFERENCE = /^[A-Z0-9]{1,40}$/;
+// A .NET clock: date, time, up to seven decimals, and an offset when one is stated.
+const CLOCK = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(\.\d{1,7})?(Z|[+-]\d{2}:\d{2})?$/;
+const CODE = /^[A-Z0-9]{1,12}$/;
+// A service centre's name. Digits or commas, which an address or a phone number has, are never read.
+const PLACE = /^\p{L}[\p{L} .'&()/-]{0,59}$/u;
+const UNKNOWN_WAYBILL = /^Invalid waybill number\b/i;
+const MAX_ROWS = 500;
+const MAX_EVENTS = 100;
+/**
+ * A GIG waybill, ten digits. Another reference the tracker may take as an
+ * Alphacode is left to the universal providers, without a request: its
+ * layout is undocumented and the reply could not be bound to it.
+ */
+export function normalizeGigLogisticsNumber(raw) {
+    const number = typeof raw === 'string' && raw.length <= 64 ? normalizeTrackingNumber(raw) : '';
+    if (WAYBILL.test(number))
+        return number;
+    if (OTHER_REFERENCE.test(number))
+        throw new IndeterminateError(PROVIDER, 'The adapter reads GIG Logistics waybills, which are ten digits');
+    throw new InvalidInputError(PROVIDER, 'GIG Logistics waybills are ten digits');
+}
+/** An optional text field; anything but a string is a changed reply. */
+function text(row, key, maxLength = 300) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'string')
+        throw new SchemaError(PROVIDER, `GIG Logistics returned an invalid ${key}`);
+    return clean(value, maxLength);
+}
+/** A scan's wall clock to the second, and its instant when the clock states an offset. */
+function scanClock(row) {
+    const raw = text(row, 'DateTime', 40);
+    const match = CLOCK.exec(raw);
+    const local = match ? `${match[1]}T${match[2]}` : '';
+    // Parsing in UTC checks the calendar digits only; Luxon rolls 24:00:00 over, so only a clock
+    // that reads back unchanged is kept. A year before 2000 is .NET's empty date.
+    const parsed = DateTime.fromISO(local, { zone: 'UTC' });
+    if (!match || !parsed.isValid || parsed.year < 2000 || parsed.toFormat("yyyy-MM-dd'T'HH:mm:ss") !== local) {
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned an invalid scan time');
+    }
+    const instant = match[4] ? explicitOffsetTime(`${local}${match[4]}`) : null;
+    // The decimals keep scans logged within one second in order.
+    const order = `${local}${(match[3] ?? '.').padEnd(8, '0')}`;
+    return instant ? { local, order, instant } : { local, order };
+}
+/** The service centre a scan names, at most; anything that could be an address is dropped. */
+function place(row) {
+    const name = clean(text(row, 'Location', 120).replace(/_/g, ' '), 60);
+    return PLACE.test(name) ? name : '';
+}
+/**
+ * The reply of the tracking page's `api/portal/trackshipment/{waybill}`
+ * lookup. A waybill it has gets `Code` "200" and its scans in
+ * `Object.MobileShipmentTrackings`, each naming its waybill, with a code and
+ * the code's fixed wording in `ScanStatus`. A waybill it does not have gets
+ * `Code` "400" and "Invalid waybill number!!". Only scans naming the whole
+ * waybill asked are read, and of them only the code, its wording, the clock
+ * and the service centre: the origin and destination addresses, the incident
+ * text the page shows, which can name the receiver, and the scanning staff
+ * are never read.
+ */
+export function parseGigLogistics(payload, raw) {
+    const number = normalizeGigLogisticsNumber(raw);
+    if (!isRecord(payload))
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned an invalid reply');
+    const code = cleanScalar(payload.Code, 8);
+    if (code !== '200') {
+        if (!code)
+            throw new SchemaError(PROVIDER, 'GIG Logistics returned an invalid reply');
+        if (code === '400' && UNKNOWN_WAYBILL.test(text(payload, 'ShortDescription', 200))) {
+            throw new NotFoundError(PROVIDER, 'GIG Logistics has no shipment under this waybill');
+        }
+        throw new IndeterminateError(PROVIDER, 'GIG Logistics did not complete the lookup');
+    }
+    const shipment = payload.Object;
+    if (!isRecord(shipment))
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned an invalid reply');
+    const rows = shipment.MobileShipmentTrackings ?? [];
+    if (!Array.isArray(rows))
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned a shipment with invalid scans');
+    if (rows.length > MAX_ROWS)
+        throw new SchemaError(PROVIDER, 'GIG Logistics returned an oversized history');
+    const seen = new Set();
+    const scans = [];
+    let others = 0;
+    for (const row of rows) {
+        if (!isRecord(row) || typeof row.Waybill !== 'string')
+            throw new SchemaError(PROVIDER, 'GIG Logistics returned an invalid scan');
+        if (normalizeTrackingNumber(row.Waybill) !== number) {
+            others += 1;
+            continue;
+        }
+        const status = isRecord(row.ScanStatus) ? row.ScanStatus : {};
+        const scanCode = (text(row, 'Status', 16) || text(status, 'Code', 16)).toUpperCase();
+        if (!CODE.test(scanCode))
+            throw new SchemaError(PROVIDER, 'GIG Logistics returned a scan without a code');
+        const clock = scanClock(row);
+        const description = text(status, 'Reason') || gigLogisticsCodeWording(scanCode) || '';
+        // A scan whose code has no wording says nothing readable.
+        if (!description)
+            continue;
+        const location = place(row);
+        const key = JSON.stringify([clock.order, scanCode, location]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const staged = gigLogisticsStage(scanCode, description);
+        scans.push({ clock, index: scans.length, event: {
+                // A scan without an offset keeps its wall clock.
+                ...(clock.instant ? { time: clock.instant.iso } : { local_time: clock.local }),
+                ...(location ? { location } : {}),
+                description,
+                provider_code: scanCode,
+                ...(staged ? { stage: staged.stage, stage_source: staged.source } : {}),
+            } });
+    }
+    if (!scans.length) {
+        if (others)
+            throw new IndeterminateError(PROVIDER, 'GIG Logistics answered for another waybill');
+        throw new NoHistoryError(PROVIDER);
+    }
+    // Newest first, by instant when every scan states one, else by wall clock; equal ones in the reply's order.
+    const timed = scans.every((scan) => scan.clock.instant);
+    scans.sort((left, right) => (timed
+        ? right.clock.instant.timestamp - left.clock.instant.timestamp
+        : right.clock.order.localeCompare(left.clock.order)) || left.index - right.index);
+    const events = scans.map((scan) => scan.event);
+    const newest = events[0];
+    // A record of the booking logged after the parcel moved is no step back.
+    const scanned = events.find((event) => event.stage && event.stage !== 'registered') ?? events.find((event) => event.stage);
+    const stage = scanned?.stage;
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: scanned.stage_source } : {}),
+        last_status_text: newest.description,
+        last_update: newest.time ?? null,
+        ...(newest.local_time ? { last_update_local: newest.local_time } : {}),
+        expected_delivery: null,
+        ...(stage === 'delivered' && scanned?.time ? { delivered_at: scanned.time } : {}),
+        events: events.slice(0, MAX_EVENTS),
+        ...(events.length > MAX_EVENTS ? { history_truncated: true } : {}),
+    };
+}

package/dist/carriers/gig-logistics/status.d.ts

@@ -0,0 +1,8 @@
+import { type ClassifiedWording } from '../../core/status/index.js';
+import { type CarrierStatusMap } from '../../core/status/statusMap.js';
+/** The wording recorded for a scan code. */
+export declare function gigLogisticsCodeWording(code: string): string | undefined;
+/** A scan's stage: its code, else its wording, else the shared wording rules, else nothing. */
+export declare function gigLogisticsStage(code: string, wording: string): ClassifiedWording | null;
+/** What the map says about a scan, by its code or its wording. */
+export declare const statusMap: CarrierStatusMap;

package/dist/carriers/gig-logistics/status.js

@@ -0,0 +1,32 @@
+import { classifyWording } from '../../core/status/index.js';
+import { normalizeStatusWording } from '../../core/status/statusMap.js';
+import statuses from './statuses.json' with { type: 'json' };
+const ENTRIES = statuses.entries;
+/**
+ * GIG's scans each have a code, such as `OKT`, and the code's fixed wording.
+ * The code is the key; a code not recorded in `statuses.json` falls to its
+ * recorded wording, then to the shared wording rules.
+ */
+const CODES = new Map(ENTRIES.filter((entry) => entry.code && entry.stage)
+    .map((entry) => [entry.code, entry.stage]));
+const WORDINGS = new Map(ENTRIES.filter((entry) => entry.wording && entry.stage)
+    .map((entry) => [normalizeStatusWording(entry.wording), entry.stage]));
+const CODE_WORDINGS = new Map(ENTRIES.filter((entry) => entry.code && entry.wording)
+    .map((entry) => [entry.code, entry.wording]));
+/** The wording recorded for a scan code. */
+export function gigLogisticsCodeWording(code) {
+    return CODE_WORDINGS.get(code);
+}
+/** A scan's stage: its code, else its wording, else the shared wording rules, else nothing. */
+export function gigLogisticsStage(code, wording) {
+    const mapped = CODES.get(code) ?? WORDINGS.get(normalizeStatusWording(wording));
+    if (mapped)
+        return { stage: mapped, source: 'carrier_map' };
+    const worded = classifyWording(wording, 'in_transit');
+    return worded.source === 'none' ? null : worded;
+}
+/** What the map says about a scan, by its code or its wording. */
+export const statusMap = {
+    stage: (code, wording) => (code ? CODES.get(code) : undefined) ?? WORDINGS.get(wording),
+    gaps: [],
+};

package/dist/carriers/mailamericas/status.js

@@ -47,9 +47,10 @@ const CODES = new Map([
 export function mailamericasMappedStage(code) {
     return CODES.get(code.toUpperCase());
 }
-// Tax ID checks (SM), notices (AV) and the record of a prepaid duty (AD-4,
-// seen while the parcel was still at the origin warehouse) move nothing.
-const NOTICE = /^(?:SM-|AV-|AD-4$)/i;
+// Tax ID checks (SM), notices (AV), the record of a prepaid duty (AD-4,
+// seen while the parcel was still at the origin warehouse) and a delivery
+// moved to a later round (LM-11) move nothing.
+const NOTICE = /^(?:SM-|AV-|AD-4$|LM-11$)/i;
 /** A scan's stage: its code, else the shared wording rules, else nothing. */
 export function mailamericasStage(code, wording) {
     const mapped = mailamericasMappedStage(code);
@@ -69,5 +70,6 @@ export const statusMap = {
         { code: 'SM-9', note: 'The buyer\'s details form received, logged again every half hour while the parcel moves on; it moves nothing.' },
         { code: 'AD-4', note: 'The import duty recorded as paid, which can come while the parcel is still at the origin warehouse; it moves nothing.' },
         { code: 'AV-1', note: 'A notice that adds information to the history; it moves nothing.' },
+        { code: 'LM-11', note: 'The delivery moved to a later round, logged after a round or beside the next one, which can deliver; it names no attempt and moves nothing.' },
     ],
 };

package/dist/carriers/mailamericas/statuses.json

@@ -40,6 +40,7 @@
     {"code": "LM-5", "wording": "Delivery office: Returned for failed delivery", "language": "en", "stage": "returned", "confirmedBy": "live"},
     {"code": "LM-7", "wording": "Delivery office: Recipient Absent", "language": "en", "stage": "failed_attempt", "confirmedBy": "live"},
     {"code": "LM-9", "wording": "Delivery office: Wrong delivery address", "language": "en", "stage": "failed_attempt", "confirmedBy": "live", "note": "The parcel went out again and was delivered in the history seen."},
+    {"code": "LM-11", "wording": "Delivery office: Rescheduling", "language": "en", "confirmedBy": "live", "unmapped": true, "note": "After a round with the postman, and again beside the next round, which delivered the parcel; it names no attempt."},
     {"code": "PF-1", "wording": "Finished: Delivered", "language": "en", "stage": "delivered", "confirmedBy": "live"},
     {"code": "PF-2", "wording": "Finished: Delivered to return address", "language": "en", "stage": "returned", "confirmedBy": "live", "note": "The summary's status reads returned."},
     {"code": "RT-1", "wording": "Return-Destruction: Received at return Warehouse", "language": "en", "stage": "returned", "confirmedBy": "live", "note": "The summary's status reads returned."},

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

@@ -0,0 +1,31 @@
+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. */
+export declare const SENDLE_PAGE = "https://www.sendle.com/tracking";
+/** The Convex deployment the tracking page's bundle calls. */
+export declare const SENDLE_API = "https://keen-orca-155.convex.cloud";
+/** The mutation that hands out a proof-of-work challenge, and the action that looks a number up with its answer. */
+export declare const SENDLE_CHALLENGE = "tracking:createChallenge";
+export declare const SENDLE_LOOKUP = "tracking:lookupTracking";
+/** Whether a digest starts with `bits` zero bits, as the page checks it. */
+export declare function sendleProofHolds(digest: Uint8Array, bits: number): boolean;
+/**
+ * The page's answer to a challenge: the first counter, written in base 36,
+ * whose SHA-256 of `salt:counter` starts with `difficulty` zero bits. The
+ * search yields between batches and stops when the lookup's signal ends or the
+ * attempt's deadline passes.
+ */
+export declare function solveSendleChallenge(salt: string, difficulty: number, signal: AbortSignal, deadline: number): Promise<string>;
+export declare class SendleTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+    });
+    /** One call of a public Convex function over its HTTP API, as JSON. */
+    private call;
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;