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

package/dist/carriers/chronopost/adapter.js

@@ -1,6 +1,7 @@
 import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
 import { IndeterminateError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
 import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
 import { CHRONOPOST_MAX_BYTES, CHRONOPOST_NAMESPACE, normalizeChronopostNumber, parseChronopostTrackingXml } from './parser.js';
 // The official WSDL declares this read-only operation without account credentials.
@@ -12,28 +13,34 @@ export class ChronopostTracker {
     }
     fetch(raw, context = {}) {
         const number = normalizeChronopostNumber(raw);
+        const read = async (signal, timeoutMs) => {
+            const { response, bytes } = await fetchBounded(ENDPOINT, {
+                method: 'POST', signal,
+                headers: { Accept: 'text/xml', 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '""',
+                    'User-Agent': userAgentOf(this.options.userAgent) },
+                body: `<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:trk="${CHRONOPOST_NAMESPACE}">`
+                    + `<soap:Body><trk:trackSkybillV2><language>fr_FR</language><skybillNumber>${number}</skybillNumber>`
+                    + '</trk:trackSkybillV2></soap:Body></soap:Envelope>',
+            }, { provider: 'Chronopost tracking', timeoutMs: Math.max(1, Math.floor(timeoutMs)),
+                maxBytes: CHRONOPOST_MAX_BYTES, allowHttpStatuses: [404, 410], fetcher: this.options.fetcher });
+            // An HTTP route failure is not the service's positive unknown-parcel reply.
+            if ([404, 410].includes(response.status))
+                throw new IndeterminateError('Chronopost', 'Chronopost tracking endpoint is unavailable');
+            return parseChronopostTrackingXml(decodeText(bytes), number);
+        };
+        // A request that fails to reach Chronopost, or hangs, gets one more try:
+        // the first gets half of the budget, so the retry fits in the rest.
         return runSteps({ carrier: 'chronopost', budgetMs: context.budgetMs ?? 15_000, signal: context.signal,
-            recorder: this.options.recorder }, [{ id: 'direct', run: async ({ signal, remainingMs }) => {
-                    const { response, bytes } = await fetchBounded(ENDPOINT, {
-                        method: 'POST', signal,
-                        headers: { Accept: 'text/xml', 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '""',
-                            'User-Agent': userAgentOf(this.options.userAgent) },
-                        body: `<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:trk="${CHRONOPOST_NAMESPACE}">`
-                            + `<soap:Body><trk:trackSkybillV2><language>fr_FR</language><skybillNumber>${number}</skybillNumber>`
-                            + '</trk:trackSkybillV2></soap:Body></soap:Envelope>',
-                    }, { provider: 'Chronopost tracking', timeoutMs: Math.max(1, Math.floor(remainingMs)),
-                        maxBytes: CHRONOPOST_MAX_BYTES, allowHttpStatuses: [404, 410], fetcher: this.options.fetcher });
-                    // An HTTP route failure is not the service's positive unknown-parcel reply.
-                    if ([404, 410].includes(response.status))
-                        throw new IndeterminateError('Chronopost', 'Chronopost tracking endpoint is unavailable');
-                    return parseChronopostTrackingXml(decodeText(bytes), number);
-                } }]);
+            recorder: this.options.recorder }, [
+            { id: 'direct', run: ({ signal, remainingMs }) => read(signal, firstAttemptMs(remainingMs)) },
+            networkRetryStep(({ signal, remainingMs }) => read(signal, remainingMs)),
+        ]);
     }
 }
 export const adapter = environment => {
     const tracker = new ChronopostTracker(environment);
     return {
-        id: 'chronopost', recordsSteps: true, steps: ['direct'],
+        id: 'chronopost', recordsSteps: true, steps: ['direct', 'retry'],
         track: (input, context) => tracker.fetch(input.number, context),
         recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeChronopostNumber(number))),
     };

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

@@ -51,6 +51,7 @@ export interface DPDParcelShops {
 export interface DPDAppTier {
     /**
      * `leads` when the guest tier is still to come and needs time left. `postcode` is empty when none was given.
+     * `waiting`, given to a leading tier, is called when the lookup starts waiting for the tier's session to open.
      * `stop` aborts when the lookup has its answer without the tier, which then reads nothing more.
      */
     run(number: string, context: {
@@ -59,11 +60,10 @@ export interface DPDAppTier {
         timeoutMs: number;
         leads: boolean;
         postcode: string;
+        waiting?: () => void;
     }): Promise<CarrierResult>;
     /** The failures of either tier the other may answer after. */
     recovers(error: unknown): boolean;
-    /** Whether a lookup would first wait for the tier's session to open. */
-    opening?(): boolean;
 }
 export declare class DPDTracker {
     #private;

package/dist/carriers/dpd/adapter.js

@@ -632,35 +632,44 @@ export class DPDTracker {
         let guest;
         const guestReply = () => guest ??= this.apiFetch(trackingNumber, resolvedPostcode, lookup);
         /**
-         * While the app's session opens, the guest tier is asked beside it. A parcel
-         * the guest tier does not know, or places in another country, the app does
-         * not answer either: the app stops waiting, reads nothing once its session
-         * opens, and the guest tier's step reports it. Otherwise the app keeps
-         * waiting, and the reply serves the guest tier's step if the session does
-         * not open in time. A failed reply is asked again there.
+         * While the app's session opens, the guest tier is asked beside it, not
+         * while a host's store gives back a saved session. A parcel the guest tier
+         * does not know, or places in another country, the app does not answer
+         * either: the app stops waiting, reads nothing once its session opens, and
+         * the guest tier's step reports it. Otherwise the app keeps waiting, because
+         * the guest tier's reply without a postcode is a summary: one entry per
+         * milestone, without places, registration, repeated delivery attempts and
+         * failures, or the parcel's size. Its clocks and wording also differ from
+         * the app's scans, so a consumer that stored it would keep both versions of
+         * a scan once a later lookup reads the app. The reply serves the guest
+         * tier's step if the session does not open in time. A failed reply is
+         * asked again there.
          */
-        const besideGuest = (tracked, stop) => {
+        const besideGuest = (stop) => {
             const reply = guestReply();
             const pending = new Promise(() => { });
-            return Promise.race([tracked, reply.then(() => pending, (error) => {
-                    if (!app.recovers(error)) {
-                        const stopped = new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', { reason: DPD_DE_SESSION_OPENING });
-                        stop.abort(stopped);
-                        throw stopped;
-                    }
-                    if (guest === reply)
-                        guest = undefined;
-                    return pending;
-                })]);
+            return reply.then(() => pending, (error) => {
+                if (!app.recovers(error)) {
+                    const stopped = new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', { reason: DPD_DE_SESSION_OPENING });
+                    stop.abort(stopped);
+                    throw stopped;
+                }
+                if (guest === reply)
+                    guest = undefined;
+                return pending;
+            });
         };
         const appStep = (leads) => ({
             id: 'app',
             ...(leads ? {} : { recovers: appRecovers }),
             run: ({ signal, remainingMs }) => {
-                const opening = leads && app.opening?.() === true;
                 const stop = new AbortController();
-                const tracked = app.run(trackingNumber, { signal, stop: stop.signal, timeoutMs: remainingMs, leads, postcode: resolvedPostcode });
-                return opening ? besideGuest(tracked, stop) : tracked;
+                const tier = { signal, stop: stop.signal, timeoutMs: remainingMs, leads, postcode: resolvedPostcode };
+                if (!leads)
+                    return app.run(trackingNumber, tier);
+                let waiting;
+                const opening = new Promise((resolve) => { waiting = resolve; });
+                return Promise.race([app.run(trackingNumber, { ...tier, waiting }), opening.then(() => besideGuest(stop))]);
             },
         });
         const result = await runSteps({

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

@@ -16,15 +16,14 @@ export const adapter = (environment) => {
         recorder: environment.recorder,
         userAgent: environment.userAgent,
         app: {
-            run: (number, { signal, stop, timeoutMs, leads, postcode }) => app.track(number, {
-                signal, stop, timeoutMs, postcode, sessionWaitMs: leads ? Math.max(0, timeoutMs - GUEST_RESERVE_MS) : timeoutMs,
+            run: (number, { signal, stop, timeoutMs, leads, postcode, waiting }) => app.track(number, {
+                signal, stop, timeoutMs, postcode, waiting, sessionWaitMs: leads ? Math.max(0, timeoutMs - GUEST_RESERVE_MS) : timeoutMs,
             }),
             // Each service has its own host, limits and outages, so either answers when
             // the other fails. Both read the same parcel: neither can place another
             // country's delivery in Germany, nor find a parcel the guest API does not know.
             recovers: error => carrierErrorKind(error) !== 'not_found'
                 && !(error instanceof CarrierError && error.reason === DPD_DE_OTHER_COUNTRY),
-            opening: () => service.opening,
         },
     });
     return {

package/dist/carriers/dpd-de/app.d.ts

@@ -25,8 +25,10 @@ export declare class DpdDeAppClient {
         now?: () => number;
     });
     /**
-     * `sessionWaitMs` bounds the wait for a session still opening; the whole `timeoutMs` by default.
-     * Once `stop` aborts, the lookup ends with its reason when the session opens, and reads nothing.
+     * `sessionWaitMs` is how long from its start the lookup may wait for a session still opening, also
+     * for one that replaces a session the service refused; the whole `timeoutMs` by default. `waiting`
+     * is called when the lookup starts waiting for one. Once `stop` aborts, the lookup stops waiting,
+     * ends with its reason and reads nothing.
      * DPD checks a `postcode` against the recipient's: a rejected one gets one lookup without it, and
      * the result says which, as on the guest API.
      */
@@ -36,5 +38,6 @@ export declare class DpdDeAppClient {
         sessionWaitMs?: number;
         postcode?: string;
         stop?: AbortSignal;
+        waiting?: () => void;
     }): Promise<CarrierResult>;
 }

package/dist/carriers/dpd-de/app.js

@@ -195,8 +195,10 @@ export class DpdDeAppClient {
         this.#service = options.service ?? new DpdAppService(options);
     }
     /**
-     * `sessionWaitMs` bounds the wait for a session still opening; the whole `timeoutMs` by default.
-     * Once `stop` aborts, the lookup ends with its reason when the session opens, and reads nothing.
+     * `sessionWaitMs` is how long from its start the lookup may wait for a session still opening, also
+     * for one that replaces a session the service refused; the whole `timeoutMs` by default. `waiting`
+     * is called when the lookup starts waiting for one. Once `stop` aborts, the lookup stops waiting,
+     * ends with its reason and reads nothing.
      * DPD checks a `postcode` against the recipient's: a rejected one gets one lookup without it, and
      * the result says which, as on the guest API.
      */
@@ -208,9 +210,12 @@ export class DpdDeAppClient {
             throw new TypeError('DPD Germany app tracking takes a 5-digit postcode');
         const deadline = performance.now() + options.timeoutMs;
         const left = () => Math.max(1, Math.floor(deadline - performance.now()));
+        const waitEnds = Math.min(deadline, performance.now() + (options.sessionWaitMs ?? Infinity));
         try {
             for (let attempt = 0;; attempt += 1) {
-                const session = await this.#service.session(options.signal, Math.min(left(), options.sessionWaitMs ?? Infinity));
+                const session = await this.#service.session(options.signal, Math.max(0, waitEnds - performance.now()), {
+                    waiting: options.waiting, stop: options.stop,
+                });
                 options.stop?.throwIfAborted();
                 // Read-only: the parcel is neither added to the session nor redirected.
                 const tracking = (zip) => this.#service.call('getTrackingData', { SessionToken: session, ParcelNo: number, DeliveryZipCode: zip,
@@ -230,11 +235,13 @@ export class DpdDeAppClient {
                         data = await tracking('');
                         verified = false;
                     }
+                    options.stop?.throwIfAborted();
                     const scans = await this.#service.call('getTrackingScanList', { SessionToken: session, ParcelNo: number,
                         DeliveryZipCode: verified ? postcode : '' }, options.signal, left());
                     const { result, shop } = parseDpdDeApp(data, scans, number);
                     // The scans name the shop without its address, which the shop's own record adds.
                     // Without it, the parcel is found all the same and its pickup point keeps the name alone.
+                    options.stop?.throwIfAborted();
                     const address = shop ? (await this.#service.parcelShop(shop, { signal: options.signal, timeoutMs: left() }))?.address : undefined;
                     if (address)
                         result.pickup_point = `${result.pickup_point}\n${address}`;

package/dist/carriers/dpd-de/carrier.json

@@ -84,7 +84,7 @@
       "domains": [
         "tracking.dpd.de"
       ],
-      "path": "^/status/[a-z]{2}_[A-Z]{2}/parcel/(\\d{14})/?$"
+      "path": "^/status/[a-z]{2}_[A-Z]{2}/parcel/(\\d{14}[0-9A-Z]?)/?$"
     },
     {
       "domains": [

package/dist/carriers/dpd-de/numbers.json

@@ -296,6 +296,32 @@
         ]
       },
       "note": "Parcel number with its printed check character, from the German consumer forum. DPD Germany's tracking returns the fourteen-digit parcel's history."
+    },
+    {
+      "number": "13499302309359E",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://web.archive.org/web/20220128062637/https://tracking.dpd.de/status/de_DE/parcel/13499302309359E",
+        "date": "2022-01-28",
+        "access": "indexed_excerpt",
+        "dateKind": "capture"
+      },
+      "context": {
+        "assessment": "candidate"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "dpd-pl",
+          "dpd",
+          "chronopost",
+          "dpd-de",
+          "dpd-uk"
+        ]
+      },
+      "note": "Printed with its check character. Its 13 depot range is the one DPD Poland's own archived tracking pages show. Neither DPD Germany nor DPD Poland found it in October 2026."
     }
   ]
 }

package/dist/carriers/dpd-de/service.d.ts

@@ -47,6 +47,32 @@ export interface DpdSessionStore {
     /** Saves a session, replacing what was saved for the same token. */
     save(session: DpdSession): Promise<void>;
 }
+/**
+ * What a long-lived host learns of the sessions the service keeps, without their tokens: a
+ * session taken up from the store at start, and each opening once it ends, whatever began it.
+ */
+export interface DpdSessionEvent {
+    outcome: 'taken_up' | 'opened' | 'failed';
+    /**
+     * What began the opening: `start` when the host kept the service, `renewal` when the current
+     * session reached its renewal age, `retry` a quarter of an hour after a failed opening,
+     * `refused` when the service no longer accepted the session, and `lookup` when a lookup found
+     * none open. A session taken up is always `start`.
+     */
+    trigger: 'start' | 'renewal' | 'retry' | 'refused' | 'lookup';
+    /** How long the opening took, or the store's load for a session taken up. */
+    durationMs: number;
+    /** For a session taken up: how long ago it opened. */
+    ageMs?: number;
+    /** For a failure: its error kind, such as `transport` or `schema`, else its class name. */
+    errorKind?: string;
+}
+/** What `keep` takes, as `warmDpdSession` does. */
+interface KeepOptions {
+    store?: DpdSessionStore;
+    /** Told of each session taken up or opening that ends. It is called apart from lookups, and what it throws or rejects is ignored. */
+    onSession?: (event: DpdSessionEvent) => void | Promise<void>;
+}
 /**
  * The service needs an anonymous device session, which it takes tens of seconds to open and then
  * accepts for hours. One is kept per instance, and `sharedDpdAppService` gives the process one
@@ -69,7 +95,7 @@ export declare class DpdAppService {
         signal: AbortSignal;
         timeoutMs: number;
     }): Promise<DpdParcelShop | undefined>;
-    /** Whether a lookup would wait for a session to open: none is open. */
+    /** Whether no session is open, as while one opens or a host's store gives back its sessions. */
     get opening(): boolean;
     /** Forgets a session the service refused, unless another lookup already replaced it. */
     expire(session: string): void;
@@ -77,16 +103,22 @@ export declare class DpdAppService {
      * Keeps a session open from now on, for a long-lived host: one opens at once if there is none,
      * and the next before the current one lapses. Openings then run whether or not a lookup waits
      * for them. With a store, the current session saved there is taken up again instead, and the
-     * sessions lookups no longer use are checked until the service refuses them. The timers do not
-     * keep the process alive.
+     * sessions lookups no longer use are checked until the service refuses them. `onSession` hears
+     * of each session taken up or opening that ends. The timers do not keep the process alive.
+     * Only the first call counts.
      */
-    keep(store?: DpdSessionStore): void;
+    keep(options?: KeepOptions): void;
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
-     * A session past its renewal age answers at once while the next one opens.
+     * A session past its renewal age answers at once while the next one opens. `waiting` is called
+     * when the lookup starts waiting for an opening, once a host's store has given back its sessions.
+     * A lookup whose `stop` aborts stops waiting with its reason, and still holds the opening.
      */
-    session(signal: AbortSignal, waitMs: number): Promise<string>;
+    session(signal: AbortSignal, waitMs: number, options?: {
+        waiting?: () => void;
+        stop?: AbortSignal;
+    }): Promise<string>;
     call(operation: string, fields: Fields, signal: AbortSignal, timeoutMs: number): Promise<XmlNode>;
 }
 /**
@@ -101,9 +133,12 @@ export declare function sharedDpdAppService(options?: Pick<AdapterEnvironment, '
  * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` it gives
  * `createTracker` or its adapter environment. With a `store`, a restart takes the saved session up
  * again, and the sessions no longer used are checked every hour until the service refuses them,
- * which the store records. The timers do not keep the process alive.
+ * which the store records. `onSession` hears of each session taken up and each opening that ends,
+ * so the host can tell how long openings take and when one fails. The timers do not keep the
+ * process alive.
  */
 export declare function warmDpdSession(environment?: Pick<AdapterEnvironment, 'fetcher' | 'userAgent'>, options?: {
     store?: DpdSessionStore;
+    onSession?: (event: DpdSessionEvent) => void | Promise<void>;
 }): void;
 export {};

package/dist/carriers/dpd-de/service.js

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { ChallengeError, IndeterminateError, SchemaError, TransportError } from '../../core/errors/index.js';
+import { carrierErrorKind, ChallengeError, errorTypeOf, IndeterminateError, SchemaError, TransportError } from '../../core/errors/index.js';
 import { clean, decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
 import { transportOf } from '../../core/transport/transportOf.js';
 import { xmlDocument } from '../../core/transport/xml.js';
@@ -116,6 +116,9 @@ export class DpdAppService {
     #kept = false;
     #timer;
     #store;
+    #onSession;
+    /** The service refused the last session, and none has opened since. */
+    #refused = false;
     #loading = null;
     #retired = new Map();
     constructor(options = {}) {
@@ -150,7 +153,7 @@ export class DpdAppService {
             return undefined;
         }
     }
-    /** Whether a lookup would wait for a session to open: none is open. */
+    /** Whether no session is open, as while one opens or a host's store gives back its sessions. */
     get opening() {
         return this.#session === null;
     }
@@ -160,29 +163,40 @@ export class DpdAppService {
             return;
         this.#retire(this.#session, this.#now());
         this.#session = null;
+        this.#refused = true;
     }
     /**
      * Keeps a session open from now on, for a long-lived host: one opens at once if there is none,
      * and the next before the current one lapses. Openings then run whether or not a lookup waits
      * for them. With a store, the current session saved there is taken up again instead, and the
-     * sessions lookups no longer use are checked until the service refuses them. The timers do not
-     * keep the process alive.
+     * sessions lookups no longer use are checked until the service refuses them. `onSession` hears
+     * of each session taken up or opening that ends. The timers do not keep the process alive.
+     * Only the first call counts.
      */
-    keep(store) {
+    keep(options = {}) {
         if (this.#kept)
             return;
         this.#kept = true;
+        const { store, onSession } = options;
         this.#store = store;
+        this.#onSession = onSession;
         if (!store)
-            return this.#renew();
+            return this.#renew('start');
         this.#loading = this.#load(store).finally(() => {
             this.#loading = null;
-            this.#renew();
+            this.#renew('start');
             this.#follow();
         });
     }
+    /** Tells the host's observer, if there is one, apart from the lookup and whatever it does. */
+    #report(event) {
+        const observer = this.#onSession;
+        if (observer)
+            void Promise.resolve().then(() => observer(event)).catch(() => undefined);
+    }
     /** Takes up the newest saved session while it is younger than the renewal age, and follows the others. */
     async #load(store) {
+        const started = this.#now();
         let timer;
         const late = new Promise((_resolve, reject) => { timer = setTimeout(() => reject(new Error('The store did not answer')), STORE_LOAD_MS); });
         let saved;
@@ -202,8 +216,10 @@ export class DpdAppService {
             && session.refusedAt == null)
             .sort((left, right) => right.openedAt - left.openedAt);
         const [newest, ...older] = sessions;
-        if (newest && !this.#session && now - newest.openedAt < SESSION_RENEW_MS)
+        if (newest && !this.#session && now - newest.openedAt < SESSION_RENEW_MS) {
             this.#session = { token: newest.token, openedAt: newest.openedAt };
+            this.#report({ outcome: 'taken_up', trigger: 'start', durationMs: Math.max(0, now - started), ageMs: now - newest.openedAt });
+        }
         else if (newest)
             older.unshift(newest);
         for (const session of older)
@@ -270,24 +286,25 @@ export class DpdAppService {
         }
     }
     /** Opens the next session if the current one is due, or waits until it is. */
-    #renew() {
+    #renew(trigger) {
         if (this.#opening)
             return;
         const age = this.#session ? this.#now() - this.#session.openedAt : Infinity;
         if (age < SESSION_RENEW_MS)
-            this.#schedule(SESSION_RENEW_MS - age);
+            this.#schedule(SESSION_RENEW_MS - age, 'renewal');
         else
-            this.#opening = this.#open();
+            this.#opening = this.#open(trigger);
     }
-    #schedule(ms) {
+    #schedule(ms, trigger) {
         if (!this.#kept)
             return;
         clearTimeout(this.#timer);
-        this.#timer = setTimeout(() => this.#renew(), ms);
+        this.#timer = setTimeout(() => this.#renew(trigger), ms);
         this.#timer.unref?.();
     }
     /** An opening, which a kept service finishes and otherwise ends when no lookup holds it. */
-    #open() {
+    #open(trigger) {
+        const started = this.#now();
         const controller = new AbortController();
         const holders = new Set();
         const token = this.call('getSessionFullState', { SessionToken: '', DeviceData: {
@@ -299,6 +316,7 @@ export class DpdAppService {
             if (this.#session)
                 this.#retire(this.#session);
             this.#session = { token: value, openedAt: this.#now() };
+            this.#refused = false;
             this.#save(this.#session);
             return value;
         });
@@ -310,7 +328,14 @@ export class DpdAppService {
                 controller.abort(new Error('No lookup is waiting for the DPD Germany session'));
         };
         const opening = { token, holders, release };
-        void token.then(() => this.#schedule(SESSION_RENEW_MS), () => this.#schedule(SESSION_RETRY_MS)).finally(() => {
+        const durationMs = () => Math.max(0, this.#now() - started);
+        void token.then(() => {
+            this.#report({ outcome: 'opened', trigger, durationMs: durationMs() });
+            this.#schedule(SESSION_RENEW_MS, 'renewal');
+        }, (error) => {
+            this.#report({ outcome: 'failed', trigger, durationMs: durationMs(), errorKind: carrierErrorKind(error) ?? errorTypeOf(error) });
+            this.#schedule(SESSION_RETRY_MS, 'retry');
+        }).finally(() => {
             if (this.#opening === opening)
                 this.#opening = null;
             for (const holder of holders)
@@ -321,9 +346,11 @@ export class DpdAppService {
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
-     * A session past its renewal age answers at once while the next one opens.
+     * A session past its renewal age answers at once while the next one opens. `waiting` is called
+     * when the lookup starts waiting for an opening, once a host's store has given back its sessions.
+     * A lookup whose `stop` aborts stops waiting with its reason, and still holds the opening.
      */
-    async session(signal, waitMs) {
+    async session(signal, waitMs, options = {}) {
         if (this.#loading)
             await until(this.#loading, signal);
         const current = this.#session;
@@ -331,7 +358,7 @@ export class DpdAppService {
         if (current && !due)
             return current.token;
         signal.throwIfAborted();
-        const opening = this.#opening ??= this.#open();
+        const opening = this.#opening ??= this.#open(current ? 'renewal' : this.#refused ? 'refused' : 'lookup');
         const { token, holders, release } = opening;
         if (!holders.has(signal)) {
             holders.add(signal);
@@ -339,21 +366,20 @@ export class DpdAppService {
         }
         if (current)
             return current.token;
-        let leave;
+        options.waiting?.();
+        const ended = options.stop ? AbortSignal.any([signal, options.stop]) : signal;
+        ended.throwIfAborted();
         let timer;
-        const left = new Promise((_resolve, reject) => {
-            leave = () => reject(signal.reason);
+        const late = new Promise((_resolve, reject) => {
             timer = setTimeout(() => reject(new IndeterminateError('DPD Germany', 'DPD Germany app session is still opening', {
                 reason: DPD_DE_SESSION_OPENING,
             })), Math.max(0, Math.min(waitMs, SESSION_OPEN_MS)));
         });
-        signal.addEventListener('abort', leave, { once: true });
         try {
-            return await Promise.race([token, left]);
+            return await until(Promise.race([token, late]), ended);
         }
         finally {
             clearTimeout(timer);
-            signal.removeEventListener('abort', leave);
         }
     }
     async call(operation, fields, signal, timeoutMs) {
@@ -413,8 +439,10 @@ export function sharedDpdAppService(options = {}) {
  * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` it gives
  * `createTracker` or its adapter environment. With a `store`, a restart takes the saved session up
  * again, and the sessions no longer used are checked every hour until the service refuses them,
- * which the store records. The timers do not keep the process alive.
+ * which the store records. `onSession` hears of each session taken up and each opening that ends,
+ * so the host can tell how long openings take and when one fails. The timers do not keep the
+ * process alive.
  */
 export function warmDpdSession(environment = {}, options = {}) {
-    sharedDpdAppService(environment).keep(options.store);
+    sharedDpdAppService(environment).keep(options);
 }

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

@@ -3,6 +3,7 @@ import { hasGs1CheckDigit } from '../../core/detection/numericChecksums.js';
 import { ChallengeError, IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
 import { eventPoint } from '../../core/result/index.js';
 import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
 import { zonedTime } from '../../core/time/index.js';
 import { TrawlClient, clean, decodeText, fetchBounded } from '../../core/transport/index.js';
 import { isDeliveryStatusCell } from './identity.js';
@@ -235,24 +236,25 @@ export class DPDFranceTracker {
         const number = normalizeDPDFranceTrackingNumber(rawTrackingNumber);
         const url = dpdFranceTrackingUrl(number);
         const trawl = this.browserService();
+        const direct = async (timeoutMs, signal) => {
+            try {
+                return await this.directGet(url, capped(this.directTimeoutMs, timeoutMs), signal);
+            }
+            catch (error) {
+                // Without a browser service there is no second tier, so the
+                // challenge has to carry the operator's next step itself.
+                if (trawl || !(error instanceof DPDFranceChallengeError))
+                    throw error;
+                throw new DPDFranceChallengeError('DPD France requires a browser challenge solver; configure FLARESOLVERR_URL');
+            }
+        };
         const html = await runSteps({
             carrier: 'dpd-fr', budgetMs: context.budgetMs ?? this.budgetMs, signal: context.signal, recorder: this.recorder,
         }, [
-            {
-                id: 'direct',
-                run: async ({ remainingMs, signal }) => {
-                    try {
-                        return await this.directGet(url, capped(this.directTimeoutMs, remainingMs), signal);
-                    }
-                    catch (error) {
-                        // Without a browser service there is no second tier, so the
-                        // challenge has to carry the operator's next step itself.
-                        if (trawl || !(error instanceof DPDFranceChallengeError))
-                            throw error;
-                        throw new DPDFranceChallengeError('DPD France requires a browser challenge solver; configure FLARESOLVERR_URL');
-                    }
-                },
-            },
+            // A GET that fails to reach DPD, or hangs, is sent once more: the first
+            // gets at most half of what is left, so the second fits in the rest.
+            { id: 'direct', run: ({ remainingMs, signal }) => direct(firstAttemptMs(remainingMs), signal) },
+            networkRetryStep(({ remainingMs, signal }) => direct(remainingMs, signal)),
             {
                 id: 'trawl',
                 enabled: trawl !== null,
@@ -315,7 +317,7 @@ export const adapter = (environment) => {
         id: 'dpd-fr',
         // One direct HTML GET, then the browser service's native scrape API when
         // Cloudflare challenges it.
-        steps: ['direct', 'trawl'],
+        steps: ['direct', 'retry', 'trawl'],
         track: (input, context) => tracker.fetch(input.number, context),
     };
 };

package/dist/carriers/dpd-pl/carrier.json

@@ -84,6 +84,13 @@
       "pattern": "^13\\d{12}$",
       "confidence": "low",
       "preferred": true
+    },
+    {
+      "id": "dpd-pl-3",
+      "pattern": "^13\\d{12}[0-9A-Z]$",
+      "confidence": "low",
+      "checksum": "dpd",
+      "preferred": true
     }
   ]
 }