universal-parcel-scraper 0.2.0 → 0.3.0-main.298

package/dist/carriers/fedex/adapter.js

@@ -1,9 +1,9 @@
 import { load } from 'cheerio';
-import { ChallengeError, InputRequiredError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError, } from '../../core/errors/index.js';
+import { ChallengeError, InputRequiredError, InvalidInputError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError, } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
 import { NOOP_RECORDER } from '../../core/telemetry/index.js';
 import { explicitOffsetTime } from '../../core/time/index.js';
-import { clean, cleanScalar, TrawlClient } from '../../core/transport/index.js';
+import { clean, cleanScalar, TRAWL_TRANSPORT_ALLOWANCE_MS, TrawlClient } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { FEDEX_CODE_STAGE, fedexStage, fedexStatus } from './status.js';
 /**
@@ -35,7 +35,7 @@ const MAX_EVENTS_TO_RETURN = 100;
 export function normalizeFedExTrackingNumber(raw) {
     const value = raw.toLocaleUpperCase('en-US').replace(/[\s.-]/g, '');
     if (!/^\d{12}$/.test(value) && !/^\d{15}$/.test(value)) {
-        throw new SchemaError('FedEx', 'FedEx tracking numbers must contain 12 or 15 digits');
+        throw new InvalidInputError('FedEx', 'FedEx tracking numbers must contain 12 or 15 digits');
     }
     return value;
 }
@@ -210,7 +210,7 @@ export class FedExTracker {
             return this.#trawl;
         return this.trawlUrl ? new TrawlClient(this.trawlUrl, this.#fetcher) : null;
     }
-    async fetch(trackingNumber) {
+    async fetch(trackingNumber, context = {}) {
         const number = normalizeFedExTrackingNumber(trackingNumber);
         // Plain HTTP probes were rejected; the dedicated route uses the browser.
         const trawl = this.#browserService();
@@ -218,9 +218,12 @@ export class FedExTracker {
             throw new ChallengeError('FedEx', 'FedEx challenged direct tracking; configure FLARESOLVERR_URL for browser fallback');
         }
         return runSteps({
-            carrier: 'fedex', budgetMs: this.timeoutMs, recorder: this.#recorder,
+            // Without a caller's budget the lookup leaves the service its own time and
+            // the request the allowance to bring the answer back.
+            carrier: 'fedex', budgetMs: context.budgetMs ?? this.timeoutMs + TRAWL_TRANSPORT_ALLOWANCE_MS, signal: context.signal,
+            recorder: this.#recorder,
         }, [
-            { id: 'trawl', run: () => this.#trawlResult(trawl, number) },
+            { id: 'trawl', run: ({ remainingMs, signal }) => this.#trawlResult(trawl, number, Math.max(1, Math.floor(Math.min(this.timeoutMs, remainingMs))), signal) },
         ]);
     }
     /**
@@ -229,19 +232,20 @@ export class FedExTracker {
      * over plain HTTP: the edge accepts the call only from the session it
      * validated. The page the browser rendered only tells a challenge apart.
      */
-    async #trawlResult(trawl, number) {
+    async #trawlResult(trawl, number, timeoutMs, signal) {
         const page = await trawl.scrape({
             url: fedexTrackingUrl(number),
             skipHttp: true,
             maxTier: 3,
-            maxTimeout: this.timeoutMs,
+            maxTimeout: timeoutMs,
             captureResponses: [TRACK_API],
             settleTimeout: SETTLE_TIMEOUT_MS,
         }, {
             provider: 'TRAWL while fetching FedEx',
-            timeoutMs: this.timeoutMs,
+            timeoutMs,
             maxBytes: MAX_BYTES,
             fetcher: this.#fetcher,
+            signal,
         });
         let captureError;
         // Newest first: a later reply is the page's final answer.
@@ -302,6 +306,6 @@ export const adapter = (environment) => {
         id: 'fedex',
         // Browser-backed direct tracking; universal recovery belongs to the caller.
         steps: ['trawl'],
-        track: (input) => tracker.fetch(input.number),
+        track: (input, context) => tracker.fetch(input.number, context),
     };
 };

package/dist/carriers/four-px/adapter.js

@@ -1,5 +1,5 @@
 import { DateTime } from 'luxon';
-import { IndeterminateError, NotFoundError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { IndeterminateError, InvalidInputError, NotFoundError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
 import { runSteps } from '../../core/runner/index.js';
 import { clean, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -8,7 +8,7 @@ const ENDPOINT = 'https://track.4px.com/track/v2/front/listTrackV3';
 export function normalizeFourPxNumber(raw) {
     const number = raw.toUpperCase().replace(/[\s.-]/g, '');
     if (!/^[A-Z0-9]{8,40}$/.test(number))
-        throw new TypeError('4PX requires an alphanumeric parcel reference');
+        throw new InvalidInputError('4PX', '4PX requires an alphanumeric parcel reference');
     return number;
 }
 function eventTime(raw) {

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

@@ -7,7 +7,7 @@
  * its result from an allowlist of status, timeline and operational-location
  * fields, so none of that reaches the result or the logs.
  */
-import type { AdapterFactory } from '../../core/adapter/index.js';
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import { NotFoundError } from '../../core/errors/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
 export { classifyStatus } from './status.js';
@@ -27,11 +27,12 @@ export interface GeodisTrackerOptions {
     timeoutMs?: number;
     /** Test seam; production uses the global fetch. */
     fetcher?: typeof fetch;
+    userAgent?: string;
 }
 export declare class GeodisTracker {
     #private;
     readonly timeoutMs: number;
     constructor(options?: GeodisTrackerOptions);
-    fetch(rawTrackingNumber: string): Promise<CarrierResult>;
+    fetch(rawTrackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;

package/dist/carriers/geodis/adapter.js

@@ -8,8 +8,9 @@
  * fields, so none of that reaches the result or the logs.
  */
 import { createHash } from 'node:crypto';
-import { IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
-import { clean, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { lookupBudget } from '../../core/adapter/index.js';
+import { IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { clean, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { classifyStatus, comparableText, includesAny } from './status.js';
 export { classifyStatus } from './status.js';
@@ -152,7 +153,7 @@ function isNotFoundCode(value) {
 export function normalizeGeodisTrackingNumber(raw) {
     const trackingNumber = raw.trim().toLocaleUpperCase('en-US');
     if (!/^1G[A-Z0-9]{10}$/.test(trackingNumber)) {
-        throw new TypeError('GEODIS tracking numbers must start with 1G and contain 12 letters and digits');
+        throw new InvalidInputError(PROVIDER, 'GEODIS tracking numbers must start with 1G and contain 12 letters and digits');
     }
     return trackingNumber;
 }
@@ -233,32 +234,36 @@ export function parseGeodisTrackingResponse(payload, rawTrackingNumber) {
 export class GeodisTracker {
     timeoutMs;
     #fetcher;
+    #userAgent;
     constructor(options = {}) {
         this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
             throw new TypeError('GEODIS timeout must be positive');
         }
         this.#fetcher = options.fetcher;
+        this.#userAgent = userAgentOf(options.userAgent);
     }
-    async fetch(rawTrackingNumber) {
+    async fetch(rawTrackingNumber, context = {}) {
         const trackingNumber = normalizeGeodisTrackingNumber(rawTrackingNumber);
+        const budget = lookupBudget(context, this.timeoutMs);
         const body = geodisRequestBody(trackingNumber);
         const timestamp = Date.now();
         const { bytes } = await fetchBounded(geodisTrackingUrl(), {
             method: 'POST',
+            signal: budget.signal,
             headers: {
                 Accept: 'application/json',
                 'Accept-Language': 'fr-FR,fr;q=0.9',
                 'Content-Type': 'application/json',
                 Origin: 'https://espace-client.geodis.com',
                 Referer: TRACKING_PAGE,
-                'User-Agent': 'Mozilla/5.0 (compatible; SwissDeliveryTracker/1.0)',
+                'User-Agent': this.#userAgent,
                 'X-GEODIS-Service': geodisServiceHeader(trackingNumber, timestamp),
             },
             body,
         }, {
             provider: 'GEODIS tracking',
-            timeoutMs: this.timeoutMs,
+            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
             maxBytes: MAX_RESPONSE_BYTES,
             fetcher: this.#fetcher,
         });
@@ -266,10 +271,10 @@ export class GeodisTracker {
     }
 }
 export const adapter = (environment) => {
-    const tracker = new GeodisTracker({ fetcher: environment.fetcher });
+    const tracker = new GeodisTracker({ fetcher: environment.fetcher, userAgent: environment.userAgent });
     return {
         id: 'geodis',
         steps: ['direct'],
-        track: (input) => tracker.fetch(input.number),
+        track: (input, context) => tracker.fetch(input.number, context),
     };
 };

package/dist/carriers/gls-ch/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { AdapterFactory } from '../../core/adapter/index.js';
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import { NotFoundError } from '../../core/errors/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
 import { type JsonObject } from '../../core/types.js';
@@ -8,6 +8,7 @@ export interface GLSSwitzerlandOptions {
     now?: () => number;
     /** Test seam; production uses the global fetch. */
     fetcher?: typeof fetch;
+    userAgent?: string;
 }
 /** Kept as a named class: the German folder narrows on it with `instanceof`. */
 export declare class GLSSwitzerlandTrackingError extends NotFoundError {
@@ -25,13 +26,13 @@ export declare class GLSSwitzerlandTracker {
     readonly timeoutMs: number;
     readonly now: () => number;
     constructor(options?: number | GLSSwitzerlandOptions);
-    fetch(rawTrackingNumber: string, rawPostcode?: string): Promise<CarrierResult>;
+    fetch(rawTrackingNumber: string, rawPostcode?: string, context?: TrackingContext): Promise<CarrierResult>;
     /**
      * Whether GLS knows a number, from the overview alone: no postcode is sent.
      * Only a 404 whose body carries GLS's `lastError: E000` is a not-found here;
      * a 400 or 403 can be a challenge, so it stays a failure.
      */
-    recognizes(rawTrackingNumber: string): Promise<boolean>;
+    recognizes(rawTrackingNumber: string, context?: TrackingContext): Promise<boolean>;
     private request;
 }
 /** Keep the verified overview's delivery owner when the postcode detail omits it. */

package/dist/carriers/gls-ch/adapter.js

@@ -1,7 +1,8 @@
 import { load } from 'cheerio';
 import { DateTime } from 'luxon';
-import { InputRequiredError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
-import { cleanScalar, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { lookupBudget } from '../../core/adapter/index.js';
+import { InputRequiredError, InvalidInputError, NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { classifyDescription, GLS_STATUSES, statusCode } from './status.js';
 // Protocol provenance (inspected 2026-08-30):
@@ -44,7 +45,7 @@ function isReturnParcel(parcel) {
 export function normalizeGLSSwitzerlandTrackingNumber(raw) {
     const value = raw.toLocaleUpperCase('en-US').replace(/[\s.-]/g, '');
     if (!/^(?:(?=[A-Z0-9]{8}$)(?=.*[A-Z])(?=.*\d)[A-Z0-9]{8}|\d{11,14})$/.test(value)) {
-        throw new InputRequiredError('GLS', 'an 8-character Track ID or an 11-to-14-digit parcel number', 'GLS tracking requires an 8-character Track ID or an 11-to-14-digit parcel number');
+        throw new InvalidInputError('GLS', 'GLS tracking requires an 8-character Track ID or an 11-to-14-digit parcel number');
     }
     return value;
 }
@@ -302,22 +303,23 @@ export function parseGLSSwitzerlandTrackingResponse(payload, rawTrackingNumber)
 function ownerCode(parcel) {
     return records(parcel.owners).reduce((found, owner) => (found || (statusCode(owner.type) === 'REQUEST' ? text(owner.code, 32) : '')), '');
 }
-function pageHeaders() {
+function pageHeaders(userAgent) {
     return {
         Accept: 'application/json',
         'Accept-Language': 'en-CH,en;q=0.9',
         Origin: 'https://gls-group.eu',
         Referer: `${TRACKING_PAGE}/`,
-        'User-Agent': 'Mozilla/5.0 (compatible; DeliveryTracker/1.0)',
+        'User-Agent': userAgent,
     };
 }
 export class GLSSwitzerlandTracker {
     timeoutMs;
     now;
     #fetcher;
+    #userAgent;
     constructor(options = {}) {
-        const { timeoutMs = DEFAULT_TIMEOUT_MS, now = Date.now, fetcher } = typeof options === 'number'
-            ? { timeoutMs: options, now: Date.now, fetcher: undefined }
+        const { timeoutMs = DEFAULT_TIMEOUT_MS, now = Date.now, fetcher, userAgent } = typeof options === 'number'
+            ? { timeoutMs: options, now: Date.now, fetcher: undefined, userAgent: undefined }
             : options;
         if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
             throw new TypeError('GLS Switzerland timeout must be positive');
@@ -325,10 +327,13 @@ export class GLSSwitzerlandTracker {
         this.timeoutMs = timeoutMs;
         this.now = now;
         this.#fetcher = fetcher;
+        this.#userAgent = userAgentOf(userAgent);
     }
-    async fetch(rawTrackingNumber, rawPostcode = '') {
+    async fetch(rawTrackingNumber, rawPostcode = '', context = {}) {
         const trackingNumber = normalizeGLSSwitzerlandTrackingNumber(rawTrackingNumber);
-        const overview = await this.request(glsSwitzerlandOverviewApiUrl(trackingNumber, this.now()));
+        // Up to two requests, each with the full request timeout.
+        const budget = lookupBudget(context, 2 * this.timeoutMs);
+        const overview = await this.request(glsSwitzerlandOverviewApiUrl(trackingNumber, this.now()), budget);
         const parcel = selectGLSParcel(overview, trackingNumber);
         if (!rawPostcode.trim())
             return parseGLSSwitzerlandTrackingResponse(overview, trackingNumber);
@@ -336,7 +341,7 @@ export class GLSSwitzerlandTracker {
         if (!/^\d{11,14}$/.test(parcelNumber)) {
             throw new SchemaError(PROVIDER, 'GLS did not return a numeric parcel number');
         }
-        const detail = await this.request(glsSwitzerlandDetailApiUrl(parcelNumber, rawPostcode, this.now(), ownerCode(parcel)));
+        const detail = await this.request(glsSwitzerlandDetailApiUrl(parcelNumber, rawPostcode, this.now(), ownerCode(parcel)), budget);
         const result = parseGLSSwitzerlandTrackingResponse(detail, parcelNumber);
         const overviewResult = parseGLSSwitzerlandTrackingResponse(overview, trackingNumber);
         return { ...result, ...glsDeliveryReference(overviewResult) };
@@ -346,13 +351,15 @@ export class GLSSwitzerlandTracker {
      * Only a 404 whose body carries GLS's `lastError: E000` is a not-found here;
      * a 400 or 403 can be a challenge, so it stays a failure.
      */
-    async recognizes(rawTrackingNumber) {
+    async recognizes(rawTrackingNumber, context = {}) {
         const trackingNumber = normalizeGLSSwitzerlandTrackingNumber(rawTrackingNumber);
+        const budget = lookupBudget(context, this.timeoutMs);
         const { response, bytes } = await fetchBounded(glsSwitzerlandOverviewApiUrl(trackingNumber, this.now()), {
-            headers: pageHeaders(),
+            signal: budget.signal,
+            headers: pageHeaders(this.#userAgent),
         }, {
             provider: 'GLS Switzerland tracking',
-            timeoutMs: this.timeoutMs,
+            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
             maxBytes: MAX_RESPONSE_BYTES,
             allowHttpError: true,
             ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
@@ -373,12 +380,13 @@ export class GLSSwitzerlandTracker {
             throw error;
         }
     }
-    async request(url) {
+    async request(url, budget) {
         const { response, bytes } = await fetchBounded(url, {
-            headers: pageHeaders(),
+            signal: budget.signal,
+            headers: pageHeaders(this.#userAgent),
         }, {
             provider: 'GLS Switzerland tracking',
-            timeoutMs: this.timeoutMs,
+            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
             maxBytes: MAX_RESPONSE_BYTES,
             allowHttpError: true,
             ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
@@ -395,11 +403,11 @@ export function glsDeliveryReference(result) {
     return result.delivery_carrier ? { delivery_carrier: result.delivery_carrier, delivery_tracking_number: result.delivery_tracking_number } : {};
 }
 export const adapter = (environment) => {
-    const tracker = new GLSSwitzerlandTracker({ fetcher: environment.fetcher });
+    const tracker = new GLSSwitzerlandTracker({ fetcher: environment.fetcher, userAgent: environment.userAgent });
     return {
         id: 'gls-ch',
         steps: ['direct'],
-        track: (input) => tracker.fetch(input.number, input.postcode ?? ''),
-        recognize: async (number) => ({ known: await tracker.recognizes(number) }),
+        track: (input, context) => tracker.fetch(input.number, input.postcode ?? '', context),
+        recognize: async (number, context) => ({ known: await tracker.recognizes(number, context) }),
     };
 };

package/dist/carriers/gls-ch/carrier.json

@@ -21,7 +21,7 @@
     "adapter": "gls-ch",
     "requirements": [
       {
-        "field": "dpdPostcode",
+        "field": "postcode",
         "validator": "swissPostcode",
         "label": "Delivery postcode",
         "type": "text",

package/dist/carriers/gls-de/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { AdapterFactory } from '../../core/adapter/index.js';
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import { NotFoundError } from '../../core/errors/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
 export interface GLSGermanyOptions {
@@ -16,13 +16,13 @@ export declare class GLSGermanyTracker {
     readonly timeoutMs: number;
     readonly now: () => number;
     constructor(options?: number | GLSGermanyOptions);
-    fetch(rawTrackingNumber: string, rawPostcode: string): Promise<CarrierResult>;
+    fetch(rawTrackingNumber: string, rawPostcode: string, context?: TrackingContext): Promise<CarrierResult>;
     /**
      * Whether GLS Germany itself recognizes an ambiguous numeric shape. Used by
      * the host's carrier-detection route, which promotes a number to `gls-de`
      * only after this returns true; a provider failure must stay a failure.
      */
-    recognizes(rawTrackingNumber: string): Promise<boolean>;
+    recognizes(rawTrackingNumber: string, context?: TrackingContext): Promise<boolean>;
     private request;
 }
 export declare const adapter: AdapterFactory;

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

@@ -1,3 +1,4 @@
+import { lookupBudget } from '../../core/adapter/index.js';
 import { NotFoundError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -28,10 +29,12 @@ export class GLSGermanyTracker {
         this.now = now;
         this.#fetcher = fetcher;
     }
-    async fetch(rawTrackingNumber, rawPostcode) {
+    async fetch(rawTrackingNumber, rawPostcode, context = {}) {
         const number = normalizeGLSSwitzerlandTrackingNumber(rawTrackingNumber);
         const postcode = normalizeGLSSwitzerlandPostcode(rawPostcode, '4,5');
-        const overview = await this.request(glsSwitzerlandOverviewApiUrl(number, this.now()));
+        // Two requests, each with the full request timeout.
+        const budget = lookupBudget(context, 2 * this.timeoutMs);
+        const overview = await this.request(glsSwitzerlandOverviewApiUrl(number, this.now()), budget);
         // Validate the overview identity before resolving a Track ID to a parcel number.
         try {
             parseGLSSwitzerlandTrackingResponse(overview, number);
@@ -50,7 +53,7 @@ export class GLSGermanyTracker {
         }
         const owners = Array.isArray(parcel.owners) ? parcel.owners.filter(isRecord) : [];
         const owner = owners.find((row) => row.type === 'REQUEST');
-        const detail = await this.request(glsSwitzerlandDetailApiUrl(String(parcel.tuNo), postcode, this.now(), String(owner?.code ?? ''), '4,5'));
+        const detail = await this.request(glsSwitzerlandDetailApiUrl(String(parcel.tuNo), postcode, this.now(), String(owner?.code ?? ''), '4,5'), budget);
         try {
             const result = parseGLSSwitzerlandTrackingResponse(detail, String(parcel.tuNo));
             // Both services use CET/CEST; expose the regional timezone to clients.
@@ -67,11 +70,12 @@ export class GLSGermanyTracker {
      * the host's carrier-detection route, which promotes a number to `gls-de`
      * only after this returns true; a provider failure must stay a failure.
      */
-    async recognizes(rawTrackingNumber) {
+    async recognizes(rawTrackingNumber, context = {}) {
         const number = normalizeGLSSwitzerlandTrackingNumber(rawTrackingNumber);
+        const budget = lookupBudget(context, this.timeoutMs);
         try {
             const url = glsSwitzerlandOverviewApiUrl(number, this.now()).replace('/GROUP/en/', '/DE/en/');
-            const overview = await this.request(url);
+            const overview = await this.request(url, budget);
             const result = parseGLSSwitzerlandTrackingResponse(overview, number);
             return result.status !== 'unknown';
         }
@@ -81,12 +85,13 @@ export class GLSGermanyTracker {
             throw error;
         }
     }
-    async request(url) {
+    async request(url, budget) {
         const { response, bytes } = await fetchBounded(url, {
+            signal: budget.signal,
             headers: { Accept: 'application/json', Referer: 'https://gls-group.eu/EU/en/parcel-tracking' },
         }, {
             provider: PROVIDER,
-            timeoutMs: this.timeoutMs,
+            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
             maxBytes: 1_000_000,
             allowHttpError: true,
             ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
@@ -107,7 +112,7 @@ export const adapter = (environment) => {
     return {
         id: 'gls-de',
         steps: ['direct'],
-        track: (input) => tracker.fetch(input.number, input.postcode ?? ''),
-        recognize: async (number) => ({ known: await tracker.recognizes(number) }),
+        track: (input, context) => tracker.fetch(input.number, input.postcode ?? '', context),
+        recognize: async (number, context) => ({ known: await tracker.recognizes(number, context) }),
     };
 };

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

@@ -20,7 +20,7 @@
     "adapter": "gls-de",
     "requirements": [
       {
-        "field": "dpdPostcode",
+        "field": "postcode",
         "validator": "swissOrFrancePostcode",
         "label": "Delivery postcode",
         "type": "text",

package/dist/carriers/gls-fr/adapter.d.ts

@@ -7,7 +7,7 @@
  * operational-location fields, so recipient names, street addresses, contacts,
  * signatures and delivery instructions never leave this module.
  */
-import type { AdapterFactory } from '../../core/adapter/index.js';
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
 export { glsFranceStatus } from './status.js';
 export declare function normalizeGLSFranceTrackingNumber(raw: string): string;
@@ -18,12 +18,13 @@ export interface GLSFranceTrackerOptions {
     timeoutMs?: number;
     /** Test seam; production uses the global fetch. */
     fetcher?: typeof fetch;
+    userAgent?: string;
 }
 export declare class GLSFranceTracker {
     #private;
     readonly timeoutMs: number;
     constructor(options?: GLSFranceTrackerOptions);
-    fetch(trackingNumber: string): Promise<CarrierResult>;
+    fetch(trackingNumber: string, context?: TrackingContext): Promise<CarrierResult>;
     private lookup;
 }
 export declare const adapter: AdapterFactory;

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

@@ -8,10 +8,11 @@
  * signatures and delivery instructions never leave this module.
  */
 import { DateTime } from 'luxon';
+import { lookupBudget } from '../../core/adapter/index.js';
 import { isValidGlsParcelNumber } from '../../core/detection/index.js';
-import { SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
+import { InvalidInputError, SchemaError, UpstreamHttpError } from '../../core/errors/index.js';
 import { EXPLICIT_OFFSET_PATTERN } from '../../core/time/index.js';
-import { cleanScalar, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { cleanScalar, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { FAILED_DELAYED_DELIVERY, glsFranceStatusCode, glsFranceStatusMetadata, } from './status.js';
 export { glsFranceStatus } from './status.js';
@@ -72,7 +73,7 @@ function printedNumber(raw) {
 export function normalizeGLSFranceTrackingNumber(raw) {
     const value = parcelNumber(printedNumber(raw));
     if (!value) {
-        throw new TypeError('GLS France tracking numbers must contain 8 letters or digits, or 11 digits (12 with a valid check digit)');
+        throw new InvalidInputError(PROVIDER, 'GLS France tracking numbers must contain 8 letters or digits, or 11 digits (12 with a valid check digit)');
     }
     return value;
 }
@@ -171,39 +172,43 @@ export function parseGLSFranceTrackingResponse(payload, trackingNumber) {
 export class GLSFranceTracker {
     timeoutMs;
     #fetcher;
+    #userAgent;
     constructor(options = {}) {
         this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
             throw new TypeError('GLS France timeout must be positive');
         }
         this.#fetcher = options.fetcher;
+        this.#userAgent = userAgentOf(options.userAgent);
     }
-    async fetch(trackingNumber) {
+    async fetch(trackingNumber, context = {}) {
         const normalized = normalizeGLSFranceTrackingNumber(trackingNumber);
         const printed = printedNumber(trackingNumber);
+        const budget = lookupBudget(context, this.timeoutMs);
         try {
-            return await this.lookup(normalized, normalized);
+            return await this.lookup(normalized, normalized, budget);
         }
         catch (error) {
             // The 11-digit parcel number is what GLS keys a parcel by. Should the
             // French backend only know the number as printed, ask for it once too.
             if (printed === normalized || !(error instanceof UpstreamHttpError) || error.status !== 404)
                 throw error;
-            return await this.lookup(printed, normalized);
+            return await this.lookup(printed, normalized, budget);
         }
     }
-    async lookup(code, normalized) {
+    async lookup(code, normalized, budget) {
         const { bytes } = await fetchBounded(`${TRACKING_API}/${encodeURIComponent(code)}`, {
+            signal: budget.signal,
             headers: {
                 Accept: 'application/json',
                 'Accept-Language': 'fr-FR,fr;q=0.9',
                 Origin: 'https://moncolis.gls-france.com',
                 Referer: `${TRACKING_PAGE}/`,
-                'User-Agent': 'Mozilla/5.0 (compatible; SwissDeliveryTracker/1.0)',
+                'User-Agent': this.#userAgent,
             },
         }, {
             provider: 'GLS France tracking',
-            timeoutMs: this.timeoutMs,
+            timeoutMs: Math.min(this.timeoutMs, budget.remainingMs()),
             maxBytes: MAX_RESPONSE_BYTES,
             fetcher: this.#fetcher,
         });
@@ -211,10 +216,10 @@ export class GLSFranceTracker {
     }
 }
 export const adapter = (environment) => {
-    const tracker = new GLSFranceTracker({ fetcher: environment.fetcher });
+    const tracker = new GLSFranceTracker({ fetcher: environment.fetcher, userAgent: environment.userAgent });
     return {
         id: 'gls-fr',
         steps: ['direct'],
-        track: (input) => tracker.fetch(input.number),
+        track: (input, context) => tracker.fetch(input.number, context),
     };
 };

package/dist/carriers/gofo/parser.js

@@ -1,6 +1,6 @@
 import { DateTime, IANAZone } from 'luxon';
 import { normalizeTrackingNumber } from '../../core/detection/index.js';
-import { IndeterminateError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { IndeterminateError, InvalidInputError, NotFoundError, SchemaError } from '../../core/errors/index.js';
 import { explicitOffsetTime } from '../../core/time/index.js';
 import { clean } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
@@ -15,7 +15,7 @@ const SUPPORT_LINE = new RegExp(String.raw `\s*(?:For delivery issues (?:&|and)
 export function normalizeGofoNumber(raw) {
     const number = normalizeTrackingNumber(raw);
     if (!/^GFUS\d{14}$/.test(number))
-        throw new TypeError('GOFO US requires a GFUS parcel reference');
+        throw new InvalidInputError('GOFO', 'GOFO US requires a GFUS parcel reference');
     return number;
 }
 function scanClock(value, scanZone) {

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

@@ -1,4 +1,4 @@
-import type { AdapterFactory } from '../../core/adapter/index.js';
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
 import type { CarrierResult } from '../../core/result/index.js';
 interface HeppnerCredential {
     trackingNumber: string;
@@ -16,12 +16,14 @@ export interface HeppnerTrackerOptions {
     timeoutMs?: number;
     /** Test seam; production uses the global fetch. */
     fetcher?: typeof fetch;
+    userAgent?: string;
 }
 export declare class HeppnerTracker {
     readonly timeoutMs: number;
     readonly fetcher?: typeof fetch;
+    private readonly userAgent;
     constructor(options?: HeppnerTrackerOptions);
-    fetch(rawTrackingNumber: string, rawPostcode: string): Promise<CarrierResult>;
+    fetch(rawTrackingNumber: string, rawPostcode: string, context?: TrackingContext): Promise<CarrierResult>;
 }
 export declare const adapter: AdapterFactory;
 export {};