universal-parcel-scraper 0.85.0-main.959 → 0.87.0-main.963

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 **142 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **143 dedicated adapters** and **5 universal fallbacks**
 
 <sub>208 catalog entries · 66 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 3,957 such statuses, each filed under one stage.
+The carrier folders record 3,978 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

@@ -6376,10 +6376,23 @@
     "timezone": "Europe/Madrid",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "gls-es",
+      "requirements": [
+        {
+          "field": "postcode",
+          "validator": "internationalPostcode",
+          "label": "Delivery postcode",
+          "type": "text",
+          "help": "GLS Spain shows a shipment only with its delivery postcode.",
+          "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+          "maxLength": 12,
+          "inputMode": "text",
+          "autoComplete": "postal-code"
+        }
+      ]
     },
     "canaryUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-    "trackingUrlTemplate": "https://mygls.gls-spain.es/e/?codigo={trackingNumber}",
+    "trackingUrlTemplate": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
     "trackingSearchUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
     "linkRules": [
       {
@@ -6391,6 +6404,12 @@
           "codigo"
         ]
       },
+      {
+        "domains": [
+          "mygls.gls-spain.es"
+        ],
+        "path": "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$"
+      },
       {
         "domains": [
           "gls-group.com",

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 208,
-  "activeAdapters": 142,
+  "activeAdapters": 143,
   "countries": 66,
   "referenceCarriers": 100,
   "comparison": {

package/dist/browser/scraper.js

@@ -5116,24 +5116,42 @@ var be = {
 		timezone: "Europe/Madrid",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "gls-es",
+			requirements: [{
+				field: "postcode",
+				validator: "internationalPostcode",
+				label: "Delivery postcode",
+				type: "text",
+				help: "GLS Spain shows a shipment only with its delivery postcode.",
+				pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+				maxLength: 12,
+				inputMode: "text",
+				autoComplete: "postal-code"
+			}]
 		},
 		canaryUrl: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-		trackingUrlTemplate: "https://mygls.gls-spain.es/e/?codigo={trackingNumber}",
+		trackingUrlTemplate: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
 		trackingSearchUrl: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-		linkRules: [{
-			domains: ["mygls.gls-spain.es"],
-			pathPattern: "^/e/?$",
-			params: ["codigo"]
-		}, {
-			domains: ["gls-group.com", "gls-group.eu"],
-			pathPattern: "^/ES/",
-			params: [
-				"match",
-				"parcelNumber",
-				"matchParcelNumber"
-			]
-		}],
+		linkRules: [
+			{
+				domains: ["mygls.gls-spain.es"],
+				pathPattern: "^/e/?$",
+				params: ["codigo"]
+			},
+			{
+				domains: ["mygls.gls-spain.es"],
+				path: "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$"
+			},
+			{
+				domains: ["gls-group.com", "gls-group.eu"],
+				pathPattern: "^/ES/",
+				params: [
+					"match",
+					"parcelNumber",
+					"matchParcelNumber"
+				]
+			}
+		],
 		detectionRules: []
 	},
 	"gls-it": {

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

@@ -0,0 +1,22 @@
+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';
+export declare const GLS_SPAIN_ENDPOINT = "https://api.consignee.gls-spain.es/api/v5/expeditions/find";
+export declare const GLS_SPAIN_SIGNING_SECRET = "gls";
+/** The page's X-Signature: hex HMAC-SHA256 of the method, the path and the X-Timestamp, one per line. */
+export declare function glsSpainSignature(timestamp: string, secret: string): string;
+/** The lookup's body: the number and the postcode, as the page sends them. */
+export declare function glsSpainLookupBody(number: string, postcode: string): string;
+export declare class GLSSpainTracker {
+    private readonly options;
+    /** `secret` undefined uses the page's shared secret; null turns the lookup off. */
+    constructor(options?: {
+        secret?: string | null;
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+        now?: () => Date;
+    });
+    fetch(raw: string, rawPostcode: string | null | undefined, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

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

@@ -0,0 +1,81 @@
+import { createHmac } from 'node:crypto';
+import { ChallengeError, IndeterminateError, SchemaError } 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, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
+import { normalizeGLSSpainNumber, normalizeGLSSpainPostcode, parseGLSSpainReply, PROVIDER } from './parser.js';
+// The service mygls.gls-spain.es asks for a shipment by number and delivery postcode.
+export const GLS_SPAIN_ENDPOINT = 'https://api.consignee.gls-spain.es/api/v5/expeditions/find';
+// The path the signature covers, without the API's prefix.
+const SIGNED_PATH = '/expeditions/find';
+// Shared request-signing secret the tracking page receives from Remote Config, distributed with the maintainer's approval.
+export const GLS_SPAIN_SIGNING_SECRET = 'gls';
+// A shipment reply is a few kilobytes.
+const MAX_BYTES = 512 * 1024;
+// A bot check or a block page instead of the service's JSON.
+const CHALLENGE = /_cf_chl_opt|cf-turnstile|<title>[^<]*(?:just a moment|attention required|access denied)/i;
+/** The page's X-Signature: hex HMAC-SHA256 of the method, the path and the X-Timestamp, one per line. */
+export function glsSpainSignature(timestamp, secret) {
+    return createHmac('sha256', secret).update(`POST\n${SIGNED_PATH}\n${timestamp}`, 'utf8').digest('hex');
+}
+/** The lookup's body: the number and the postcode, as the page sends them. */
+export function glsSpainLookupBody(number, postcode) {
+    return JSON.stringify({ find: { reference: number, destination: { address: { postalCode: postcode } } } });
+}
+export class GLSSpainTracker {
+    options;
+    /** `secret` undefined uses the page's shared secret; null turns the lookup off. */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, rawPostcode, context = {}) {
+        const number = normalizeGLSSpainNumber(raw);
+        const postcode = normalizeGLSSpainPostcode(rawPostcode);
+        if (this.options.secret === null)
+            throw new ChallengeError(PROVIDER, 'GLS Spain tracking is turned off by configuration');
+        const secret = this.options.secret ?? GLS_SPAIN_SIGNING_SECRET;
+        const body = glsSpainLookupBody(number, postcode);
+        const read = async (signal, timeoutMs) => {
+            // The service refuses a timestamp minutes away from its clock, so each try signs anew.
+            const timestamp = (this.options.now?.() ?? new Date()).toISOString();
+            const { response, bytes } = await fetchBounded(GLS_SPAIN_ENDPOINT, { method: 'POST', body, signal, headers: {
+                    Accept: 'application/json', 'Accept-Language': 'en_US', 'Content-Type': 'application/json; charset=utf-8',
+                    'MyGls-Agent': 'pwa', 'X-Timestamp': timestamp, 'X-Signature': glsSpainSignature(timestamp, secret),
+                    'User-Agent': userAgentOf(this.options.userAgent),
+                } }, { provider: PROVIDER, timeoutMs: Math.max(1, Math.floor(timeoutMs)), maxBytes: MAX_BYTES,
+                allowHttpStatuses: [404], fetcher: this.options.fetcher });
+            const head = decodeText(bytes.subarray(0, 4_096));
+            if (/^\s*</.test(head)) {
+                if (CHALLENGE.test(head))
+                    throw new ChallengeError(PROVIDER, 'GLS Spain asked for a browser check');
+                throw new IndeterminateError(PROVIDER, 'GLS Spain answered with a web page instead of tracking data');
+            }
+            let payload;
+            try {
+                payload = parseJsonBytes(bytes, PROVIDER);
+            }
+            catch (cause) {
+                throw new SchemaError(PROVIDER, 'GLS Spain returned invalid tracking JSON', { cause });
+            }
+            return parseGLSSpainReply(response.status, payload, number);
+        };
+        // A request that fails to reach GLS, or hangs, gets one more try: the
+        // first gets half of the budget, so the retry fits in the rest.
+        return runSteps({ carrier: 'gls-es', 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 secret = environment.env.GLS_ES_SIGNING_SECRET;
+    const tracker = new GLSSpainTracker({ secret: secret === undefined ? undefined : secret.trim() || null,
+        fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
+    // The postcode is part of every lookup, so the adapter cannot recognize a number alone.
+    return {
+        id: 'gls-es', recordsSteps: true, steps: ['direct', 'retry'],
+        track: (input, context) => tracker.fetch(input.number, input.postcode, context),
+    };
+};

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

@@ -19,18 +19,88 @@
   "timezone": "Europe/Madrid",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "gls-es",
+    "requirements": [
+      {
+        "field": "postcode",
+        "validator": "internationalPostcode",
+        "label": "Delivery postcode",
+        "type": "text",
+        "help": "GLS Spain shows a shipment only with its delivery postcode.",
+        "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+        "maxLength": 12,
+        "inputMode": "text",
+        "autoComplete": "postal-code"
+      }
+    ],
+    "steps": [
+      "direct",
+      "retry"
+    ]
   },
-  "capabilities": [],
+  "capabilities": [
+    "history",
+    "delivered_at",
+    "eta",
+    "pickup_point",
+    "weight",
+    "provider_code",
+    "canonical_tracking_number"
+  ],
   "portal": {
-    "url": "https://mygls.gls-spain.es/e/?codigo={trackingNumber}",
+    "url": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
     "searchUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
     "canaryUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-    "shows": [],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "shows": [
+      "status",
+      "history",
+      "eta",
+      "delivered_at",
+      "pickup_point",
+      "pickup_point_address",
+      "pickup_deadline",
+      "pickup_code",
+      "weight",
+      "parcel_count",
+      "progress_rail",
+      "sender_name",
+      "customer_reference",
+      "origin",
+      "destination",
+      "office_contact_details",
+      "recipient_name",
+      "recipient_verification",
+      "payment_details"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "eta",
+      "delivered_at",
+      "pickup_point",
+      "weight",
+      "provider_code",
+      "offset_timestamps"
+    ],
+    "discarded": [
+      "pickup_point_address",
+      "pickup_deadline",
+      "pickup_code",
+      "parcel_count",
+      "progress_rail",
+      "sender_name",
+      "customer_reference",
+      "origin",
+      "destination",
+      "office_contact_details",
+      "recipient_name",
+      "recipient_verification",
+      "payment_details"
+    ],
+    "unavailable": [
+      "location",
+      "service_name"
+    ]
   },
   "links": [
     {
@@ -42,6 +112,12 @@
         "codigo"
       ]
     },
+    {
+      "domains": [
+        "mygls.gls-spain.es"
+      ],
+      "path": "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$"
+    },
     {
       "domains": [
         "gls-group.com",

package/dist/carriers/gls-es/parser.d.ts

@@ -0,0 +1,20 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "GLS Spain";
+/** A number as the tracking service takes it: letters and digits, without spaces or dashes. */
+export declare function normalizeGLSSpainNumber(raw: string): string;
+/** The delivery postcode, which the service asks for with every number. */
+export declare function normalizeGLSSpainPostcode(raw: string | null | undefined): string;
+/**
+ * The `found` shipment of `POST /expeditions/find`. The service looked the
+ * whole number up with the postcode; the reply names the shipment it
+ * resolved, which may hold the number as a parcel barcode or reference it does
+ * not echo. Its addresses, the sender, the recipient and their document, the
+ * point's collection code and the scans' reasons are never read.
+ */
+export declare function parseGLSSpain(payload: unknown, raw: string): CarrierResult;
+/**
+ * The service's reply to a lookup. A 404 with its own not-found error is the
+ * only missing shipment: no shipment has the number with that postcode. Any
+ * other error reply leaves the answer open.
+ */
+export declare function parseGLSSpainReply(status: number, payload: unknown, raw: string): CarrierResult;

package/dist/carriers/gls-es/parser.js

@@ -0,0 +1,166 @@
+import { DateTime } from 'luxon';
+import { DELIVERY_POSTCODE, deliveryPostcodeText } from '../../core/catalog/postcode.js';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InputRequiredError, InvalidInputError, 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 { glsSpainStage } from './status.js';
+export const PROVIDER = 'GLS Spain';
+// The service takes a shipment number, a parcel's barcode or the sender's
+// reference, all letters and digits.
+const NUMBER = /^[A-Z0-9]{5,40}$/;
+// The scans that leave the parcel at a GLS point.
+const AT_POINT = new Set(['receivedOnParcel', 'deliveredOnParcel']);
+const MAX_SCANS = 500;
+const MAX_EVENTS = 100;
+/** A number as the tracking service takes it: letters and digits, without spaces or dashes. */
+export function normalizeGLSSpainNumber(raw) {
+    const number = raw.length <= 64 ? normalizeTrackingNumber(raw) : '';
+    if (!NUMBER.test(number)) {
+        throw new InvalidInputError(PROVIDER, 'GLS Spain looks up shipment numbers, parcel barcodes and sender references of letters and digits');
+    }
+    return number;
+}
+/** The delivery postcode, which the service asks for with every number. */
+export function normalizeGLSSpainPostcode(raw) {
+    const postcode = deliveryPostcodeText(raw ?? '');
+    if (!postcode)
+        throw new InputRequiredError(PROVIDER, 'postcode', 'GLS Spain requires the delivery postcode');
+    if (!DELIVERY_POSTCODE.test(postcode))
+        throw new InvalidInputError(PROVIDER, 'GLS Spain requires a valid delivery postcode');
+    return postcode;
+}
+/** An optional text field; an object, array or other non-scalar is a changed reply. */
+function text(row, key, maxLength = 500) {
+    const value = row[key];
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value !== 'string' && typeof value !== 'number')
+        throw new SchemaError(PROVIDER, `GLS Spain returned an invalid ${key}`);
+    return typeof value === 'number' ? cleanScalar(value, maxLength) : clean(value, maxLength);
+}
+/** One scan: its state code, sentence and instant. Its reason is never read. */
+function scan(row) {
+    if (!isRecord(row))
+        throw new SchemaError(PROVIDER, 'GLS Spain returned an invalid scan');
+    const code = text(row, 'code', 64);
+    const description = text(row, 'description');
+    if (!code || !description)
+        throw new SchemaError(PROVIDER, 'GLS Spain returned a scan without a state or wording');
+    let time;
+    if (row.at !== null && row.at !== undefined) {
+        // The app reads the clock as an instant and shows it in the reader's zone.
+        const at = explicitOffsetTime(row.at);
+        if (!at)
+            throw new SchemaError(PROVIDER, 'GLS Spain returned a scan without an offset time');
+        time = at.iso;
+    }
+    const stage = glsSpainStage(code, description);
+    return { ...(time ? { time } : {}), description, provider_code: code,
+        ...(stage ? { stage: stage.stage, stage_source: stage.source } : {}) };
+}
+/** The shipment's estimated delivery day in Spain; the service sends a day or an instant. */
+function estimatedDay(state) {
+    const raw = text(state, 'estimatedDeliveryDate', 64);
+    if (!raw)
+        return null;
+    const day = /^\d{4}-\d{2}-\d{2}$/.test(raw) ? DateTime.fromISO(raw, { zone: 'Europe/Madrid' })
+        : explicitOffsetTime(raw) ? DateTime.fromISO(raw, { setZone: true }).setZone('Europe/Madrid') : null;
+    return day?.isValid ? day.toISODate() : null;
+}
+/**
+ * The GLS point the parcel waits at or was collected from, by name, when the
+ * scan that left it there names the same point. The reply's point is the
+ * destination depot otherwise.
+ */
+function pickupPoint(found, events, stage) {
+    // The newest scan, or on a delivered parcel the one before its collection.
+    const left = stage === 'ready_for_pickup' ? events[0]
+        : stage === 'delivered' && events[0]?.stage === 'delivered' ? events[1] : undefined;
+    if (!left || !AT_POINT.has(left.provider_code ?? ''))
+        return '';
+    const name = isRecord(found.parcelShop) ? text(found.parcelShop, 'name', 120) : '';
+    return name && left.description.toLocaleLowerCase('es').includes(name.toLocaleLowerCase('es')) ? name : '';
+}
+/**
+ * The `found` shipment of `POST /expeditions/find`. The service looked the
+ * whole number up with the postcode; the reply names the shipment it
+ * resolved, which may hold the number as a parcel barcode or reference it does
+ * not echo. Its addresses, the sender, the recipient and their document, the
+ * point's collection code and the scans' reasons are never read.
+ */
+export function parseGLSSpain(payload, raw) {
+    const number = normalizeGLSSpainNumber(raw);
+    const found = isRecord(payload) && isRecord(payload.found) ? payload.found : null;
+    if (!found)
+        throw new SchemaError(PROVIDER, 'GLS Spain returned an unexpected reply');
+    const shipment = text(found, 'expeditionCode', 40);
+    if (!/^\d{1,20}$/.test(shipment))
+        throw new SchemaError(PROVIDER, 'GLS Spain returned a shipment without its number');
+    if (!isRecord(found.state))
+        throw new SchemaError(PROVIDER, 'GLS Spain returned a shipment without its state');
+    const state = found.state;
+    const stateCode = text(state, 'code', 64);
+    const stateText = text(state, 'description');
+    if (!stateCode)
+        throw new SchemaError(PROVIDER, 'GLS Spain returned a shipment without its state');
+    const rows = found.tracking ?? [];
+    if (!Array.isArray(rows) || rows.length > MAX_SCANS)
+        throw new SchemaError(PROVIDER, 'GLS Spain returned an invalid scan list');
+    // The reply lists the scans newest first.
+    const events = [];
+    const seen = new Set();
+    for (const row of rows) {
+        const event = scan(row);
+        const key = JSON.stringify([event.time, event.provider_code, event.description]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        events.push(event);
+    }
+    const newest = events[0];
+    // The shipment's state is what the app heads its page with; the newest scan
+    // of the same state reads the same, with its sentence.
+    const current = newest?.stage && newest.provider_code === stateCode
+        ? { stage: newest.stage, source: newest.stage_source }
+        : glsSpainStage(stateCode, stateText);
+    const stage = current?.stage;
+    const delivered = stage === 'delivered' ? events.find((event) => event.stage === 'delivered')?.time : undefined;
+    const point = pickupPoint(found, events, stage);
+    const weight = isRecord(found.attributes) ? found.attributes.weight : undefined;
+    const lastText = newest?.description ?? stateText;
+    if (!lastText)
+        throw new SchemaError(PROVIDER, 'GLS Spain returned a shipment without wording');
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(current ? { current_stage: current.stage, current_stage_source: current.source } : {}),
+        last_status_text: lastText,
+        last_update: newest?.time ?? null,
+        expected_delivery: stage && !['delivered', 'returned'].includes(stage) ? estimatedDay(state) : null,
+        ...(delivered ? { delivered_at: delivered } : {}),
+        ...(point ? { pickup_point: point } : {}),
+        ...(typeof weight === 'number' && Number.isFinite(weight) && weight > 0 && weight <= 10_000 ? { weight_kg: weight } : {}),
+        ...(shipment !== number ? { canonical_tracking_number: shipment } : {}),
+        ...(events.length ? {} : { provider_code: stateCode, summary_only: true }),
+        events: events.slice(0, MAX_EVENTS),
+        ...(events.length > MAX_EVENTS ? { history_truncated: true } : {}),
+    };
+}
+/**
+ * The service's reply to a lookup. A 404 with its own not-found error is the
+ * only missing shipment: no shipment has the number with that postcode. Any
+ * other error reply leaves the answer open.
+ */
+export function parseGLSSpainReply(status, payload, raw) {
+    const error = isRecord(payload) && isRecord(payload.error) ? payload.error : null;
+    if (status === 404) {
+        if (error?.name === 'NotFoundError' && error.details === 'notFound' && !('found' in payload))
+            throw new NotFoundError(PROVIDER);
+        throw new IndeterminateError(PROVIDER, 'GLS Spain answered with an error instead of the shipment');
+    }
+    if (error)
+        throw new IndeterminateError(PROVIDER, 'GLS Spain answered with an error instead of the shipment');
+    return parseGLSSpain(payload, raw);
+}

package/dist/carriers/gls-es/status.d.ts

@@ -0,0 +1,16 @@
+import { type ClassifiedWording, type Stage } from '../../core/status/index.js';
+import { type CarrierStatusMap } from '../../core/status/statusMap.js';
+/**
+ * The tracking service's state codes, the same for the shipment's current
+ * state and each scan. `stored` is left out: the app gives it no milestone of
+ * its own, so its sentence decides.
+ */
+export declare const GLS_SPAIN_STATES: Readonly<Record<string, Stage>>;
+/**
+ * Incidence sentences in the service's English, mapped whole. An incidence
+ * covers a missed delivery as much as a refusal; others stay exceptions.
+ */
+export declare const GLS_SPAIN_INCIDENCES: Readonly<Record<string, Stage>>;
+/** The stage of a state code and its sentence: the map first, then the shared wording rules. */
+export declare function glsSpainStage(code: string, sentence: string): ClassifiedWording | null;
+export declare const statusMap: CarrierStatusMap;

package/dist/carriers/gls-es/status.js

@@ -0,0 +1,67 @@
+import { classifyWording } from '../../core/status/index.js';
+import { normalizeStatusWording } from '../../core/status/statusMap.js';
+/**
+ * The tracking service's state codes, the same for the shipment's current
+ * state and each scan. `stored` is left out: the app gives it no milestone of
+ * its own, so its sentence decides.
+ */
+export const GLS_SPAIN_STATES = {
+    dataReceived: 'registered',
+    // Collected from the sender.
+    picked: 'accepted',
+    onTransit: 'in_transit',
+    onDelivery: 'out_for_delivery',
+    delivered: 'delivered',
+    // Part of a shipment of several parcels is still on its way.
+    partiallyDelivered: 'in_transit',
+    returned: 'returned',
+    // On its way back to the sender.
+    onReturn: 'returned',
+    destroyed: 'exception',
+    retained: 'exception',
+    broken: 'exception',
+    // Sent on to another address or depot.
+    rechannelized: 'in_transit',
+    // Left at a GLS point, then booked in by it with the collection code and deadline the app shows.
+    deliveredOnParcel: 'ready_for_pickup',
+    receivedOnParcel: 'ready_for_pickup',
+    canceled: 'exception',
+    incidence: 'exception',
+    // A collection from the recipient, such as a return, waiting for the driver.
+    pickupPending: 'registered',
+    pickupIncidence: 'exception',
+};
+/**
+ * Incidence sentences in the service's English, mapped whole. An incidence
+ * covers a missed delivery as much as a refusal; others stay exceptions.
+ */
+export const GLS_SPAIN_INCIDENCES = {
+    Absent: 'failed_attempt',
+    'Refused by the consignee': 'exception',
+};
+// The incidence that sends the parcel on to a GLS point, followed by the point's name.
+const REDIRECTED = /^shipment redirected to gls point /;
+const INCIDENCES = new Map(Object.entries(GLS_SPAIN_INCIDENCES).map(([wording, stage]) => [normalizeStatusWording(wording), stage]));
+/** The stage a state code gives, with the sentence an incidence needs. */
+function mappedStage(code, wording) {
+    if (!code || !Object.hasOwn(GLS_SPAIN_STATES, code))
+        return undefined;
+    if (code !== 'incidence')
+        return GLS_SPAIN_STATES[code];
+    return INCIDENCES.get(wording) ?? (REDIRECTED.test(wording) ? 'in_transit' : GLS_SPAIN_STATES[code]);
+}
+/** The stage of a state code and its sentence: the map first, then the shared wording rules. */
+export function glsSpainStage(code, sentence) {
+    const mapped = mappedStage(code, normalizeStatusWording(sentence));
+    if (mapped)
+        return { stage: mapped, source: 'carrier_map' };
+    const worded = classifyWording(sentence, 'in_transit');
+    return worded.source === 'none' ? null : worded;
+}
+export const statusMap = {
+    stage: mappedStage,
+    gaps: [{
+            code: 'stored',
+            note: 'Held at a GLS depot. The app gives the state no milestone of its own, so the scan\'s sentence decides.',
+        }],
+};

package/dist/carriers/gls-es/statuses.json

@@ -1,4 +1,175 @@
 {
   "carrier": "gls-es",
-  "entries": []
+  "entries": [
+    {
+      "code": "dataReceived",
+      "wording": "Label created. The shipment has not yet been delivered to GLS by the sender",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "The sender created the label and has not handed the parcel over. The first scan."
+    },
+    {
+      "code": "picked",
+      "wording": "Parcel picked up by GLS. Pending to arrive to final destination",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "Collected from the sender."
+    },
+    {
+      "code": "onTransit",
+      "wording": "At delivery agency",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "At the delivering depot; it can repeat."
+    },
+    {
+      "code": "onDelivery",
+      "wording": "Out for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "On the delivery round."
+    },
+    {
+      "code": "delivered",
+      "wording": "Delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "Delivered, at the door or collected from a GLS point."
+    },
+    {
+      "code": "incidence",
+      "wording": "Absent",
+      "language": "en",
+      "stage": "failed_attempt",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "A missed delivery: nobody was in."
+    },
+    {
+      "code": "incidence",
+      "wording": "Refused by the consignee",
+      "language": "en",
+      "stage": "exception",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "A return to the sender follows."
+    },
+    {
+      "code": "incidence",
+      "wording": "Shipment redirected to GLS Point <point>",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "After a missed delivery, sent on to a GLS point; the point's name follows."
+    },
+    {
+      "code": "receivedOnParcel",
+      "wording": "Received in <point>",
+      "language": "en",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "Booked in by the GLS point, which keeps it until a deadline; the point's name follows."
+    },
+    {
+      "code": "onReturn",
+      "wording": "Return delivery process",
+      "language": "en",
+      "stage": "returned",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "On its way back to the sender after a refusal."
+    },
+    {
+      "code": "returned",
+      "wording": "Returned to the shipper",
+      "language": "en",
+      "stage": "returned",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "Back with the sender."
+    },
+    {
+      "code": "canceled",
+      "wording": "Cancelled",
+      "language": "en",
+      "stage": "exception",
+      "confirmedBy": "live",
+      "firstSeen": "2026-10-11",
+      "note": "The sender cancelled the label before handing the parcel over."
+    },
+    {
+      "code": "partiallyDelivered",
+      "stage": "in_transit",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Part of a shipment of several parcels is still on its way. A state code of the tracking page; no reply showed it."
+    },
+    {
+      "code": "stored",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Held at a GLS depot. The page gives the state no milestone of its own, so the scan's sentence decides. No reply showed it."
+    },
+    {
+      "code": "destroyed",
+      "stage": "exception",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "A state code of the tracking page; no reply showed it."
+    },
+    {
+      "code": "retained",
+      "stage": "exception",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Held, the page shows a notice instead of a date. No reply showed it."
+    },
+    {
+      "code": "broken",
+      "stage": "exception",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Damaged. A state code of the tracking page; no reply showed it."
+    },
+    {
+      "code": "rechannelized",
+      "stage": "in_transit",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Sent on to another address or depot. A state code of the tracking page; no reply showed it."
+    },
+    {
+      "code": "deliveredOnParcel",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "Left at a GLS point; the page shows it with the point's icon and a notice, not as a completed delivery. No reply showed it."
+    },
+    {
+      "code": "pickupPending",
+      "stage": "registered",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "A collection from the recipient, such as a return, waiting for the driver. No reply showed it."
+    },
+    {
+      "code": "pickupIncidence",
+      "stage": "exception",
+      "confirmedBy": "bundle",
+      "firstSeen": "2026-10-11",
+      "note": "A failed collection from the recipient. No reply showed it."
+    }
+  ]
 }

package/dist/carriers/royal-mail/adapter.d.ts

@@ -6,6 +6,8 @@ export { normalizeRoyalMailNumber, parseRoyalMailTrackingHtml, parseRoyalMailTra
 export interface RoyalMailTrackerOptions {
     /** Fresh local Chromium; preferred when supplied. */
     executablePath?: string | null;
+    /** An `http://` or `socks5://` proxy for the local Chromium's traffic. */
+    browserProxy?: string | null;
     timeoutMs?: number;
     /** Legacy configuration seam; `trawl` is preferred. */
     trawlUrl?: string;

package/dist/carriers/royal-mail/adapter.js

@@ -19,6 +19,7 @@ export class RoyalMailTracker {
     #recorder;
     #fullHistory;
     #executablePath;
+    #browserProxy;
     constructor(options = {}) {
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
             throw new TypeError('Royal Mail timeout must be positive');
@@ -30,6 +31,7 @@ export class RoyalMailTracker {
         this.#recorder = options.recorder ?? NOOP_RECORDER;
         this.#fullHistory = options.fullHistory ?? false;
         this.#executablePath = options.executablePath ?? null;
+        this.#browserProxy = options.browserProxy?.trim() || null;
     }
     /** The injected browser service, or one built from the configured URL. */
     #browserService() {
@@ -41,7 +43,7 @@ export class RoyalMailTracker {
         const number = normalizeRoyalMailNumber(trackingNumber);
         if (this.#executablePath) {
             return runSteps({ carrier: 'royal-mail', budgetMs: context.budgetMs ?? this.timeoutMs,
-                signal: context.signal, recorder: this.#recorder }, [{ id: 'browser', run: ({ remainingMs, signal }) => fetchRoyalMailInBrowser(number, this.#executablePath, signal, Math.min(60_000, remainingMs), this.#fullHistory) }]);
+                signal: context.signal, recorder: this.#recorder }, [{ id: 'browser', run: ({ remainingMs, signal }) => fetchRoyalMailInBrowser(number, this.#executablePath, signal, Math.min(60_000, remainingMs), this.#fullHistory, this.#browserProxy) }]);
         }
         // The legacy service remains available through explicit tracker instances.
         const trawl = this.#browserService();
@@ -169,7 +171,7 @@ export class RoyalMailTracker {
 }
 export const adapter = environment => {
     const tracker = new RoyalMailTracker({ executablePath: environment.browserExecutablePath,
-        recorder: environment.recorder, fullHistory: true });
+        browserProxy: environment.env.ROYAL_MAIL_BROWSER_PROXY, recorder: environment.recorder, fullHistory: true });
     return {
         id: 'royal-mail', recordsSteps: true, steps: ['browser'],
         track: (input, context) => {

package/dist/carriers/royal-mail/browser.d.ts

@@ -8,4 +8,4 @@ export declare function royalMailDestination(summary: unknown): {
 };
 /** Observe the application's request; its issued session stays in the browser. */
 export declare function captureRoyalMailReply(page: Page, url: string, number: string, phase: 'summary' | 'events', signal: AbortSignal, timeoutMs: number, trigger: () => Promise<void>): Promise<Record<string, unknown>>;
-export declare function fetchRoyalMailInBrowser(number: string, executablePath: string, signal: AbortSignal, timeoutMs: number, fullHistory: boolean): Promise<CarrierResult>;
+export declare function fetchRoyalMailInBrowser(number: string, executablePath: string, signal: AbortSignal, timeoutMs: number, fullHistory: boolean, proxy?: string | null): Promise<CarrierResult>;

package/dist/carriers/royal-mail/browser.js

@@ -24,8 +24,15 @@ export async function captureRoyalMailReply(page, url, number, phase, signal, ti
     void reply.catch(() => { });
     const matches = (request) => active && request.url() === url && request.method() === 'GET'
         && ['xhr', 'fetch'].includes(request.resourceType()) && request.frame() === page.mainFrame();
-    const failed = (request) => { if (matches(request))
-        reject(new TransportError(PROVIDER, 'Royal Mail tracking request failed')); };
+    // The edge refuses a session it scores as automated by resetting the request's
+    // stream, while the page and its scripts load normally.
+    const failed = (request) => {
+        if (!matches(request))
+            return;
+        reject(request.failure()?.errorText === 'net::ERR_HTTP2_PROTOCOL_ERROR'
+            ? new ChallengeError(PROVIDER, "Royal Mail's edge refused the tracking request")
+            : new TransportError(PROVIDER, 'Royal Mail tracking request failed'));
+    };
     const aborted = () => reject(signal.aborted ? signal.reason : new TransportError(PROVIDER, 'Royal Mail tracking response timed out'));
     const received = (response) => {
         if (!matches(response.request()))
@@ -112,8 +119,8 @@ export async function captureRoyalMailReply(page, url, number, phase, signal, ti
         deadline.removeEventListener('abort', aborted);
     }
 }
-export function fetchRoyalMailInBrowser(number, executablePath, signal, timeoutMs, fullHistory) {
-    return withLocalBrowser({ provider: PROVIDER, executablePath, signal, timeoutMs,
+export function fetchRoyalMailInBrowser(number, executablePath, signal, timeoutMs, fullHistory, proxy = null) {
+    return withLocalBrowser({ provider: PROVIDER, executablePath, signal, timeoutMs, proxy,
         args: ['--disable-blink-features=AutomationControlled'] }, async ({ browser, signal: session, remainingMs }) => {
         try {
             const platform = process.platform === 'darwin' ? 'Macintosh; Intel Mac OS X 10_15_7'

package/dist/core/catalog/statusMaps.js

@@ -31,6 +31,7 @@ import { statusMap as emile } from '../../carriers/emile/status.js';
 import { statusMap as fanCourier } from '../../carriers/fan-courier/status.js';
 import { statusMap as foxpost } from '../../carriers/foxpost/status.js';
 import { statusMap as geniki } from '../../carriers/geniki-taxydromiki/status.js';
+import { statusMap as glsEs } from '../../carriers/gls-es/status.js';
 import { statusMap as glsIt } from '../../carriers/gls-it/status.js';
 import { statusMap as gofoFr } from '../../carriers/gofo-fr/status.js';
 import { statusMap as gofoIt } from '../../carriers/gofo-it/status.js';
@@ -66,7 +67,7 @@ import { CARRIER_DEFINITIONS } from './definitions.js';
 export const STATUS_MAPS = {
     'acs-courier': acsCourier, aliexpress, 'an-post': anPost, 'aras-kargo': arasKargo, 'box-now': boxNow, cacesa, 'china-post': chinaPost, chronopost,
     'correos-spain': correosSpain, 'dhl-express': dhlExpress, dpd, 'dpd-de': dpdDe, 'dpd-fr': dpdFr, 'dpd-ie': dpdIe, 'dpd-pl': dpdPl, econt, elta,
-    emile, 'fan-courier': fanCourier, foxpost, 'geniki-taxydromiki': geniki, 'gls-it': glsIt, 'gofo-fr': gofoFr, 'gofo-it': gofoIt, helthjem,
+    emile, 'fan-courier': fanCourier, foxpost, 'geniki-taxydromiki': geniki, 'gls-es': glsEs, 'gls-it': glsIt, 'gofo-fr': gofoFr, 'gofo-it': gofoIt, helthjem,
     'j-and-t': jAndT, 'j-and-t-cargo': jntCargo, 'la-poste': laPoste, matkahuolto, 'old-dominion': oldDominion, omgo, omniva,
     'orlen-paczka': orlenPaczka, postlogistics, ppl, ptt, sagawa, sameday, speedx, speedy, sto, 'swiss-post': swissPost, 'thailand-post': thailandPost,
     tnt, ups, venipak, 'vinted-go': vintedGo, yunexpress, 'yurtici-kargo': yurticiKargo,

package/dist/core/transport/localBrowser.d.ts

@@ -13,6 +13,8 @@ export interface LocalBrowserOptions {
     timeoutMs: number;
     signal?: AbortSignal;
     args?: readonly string[];
+    /** An `http://` or `socks5://` host and port that carries all of the browser's traffic. */
+    proxy?: string | null;
 }
 export interface LocalBrowserSession {
     browser: Browser;

package/dist/core/transport/localBrowser.js

@@ -3,11 +3,25 @@ import { loadChromium } from './optional.js';
 /** Covers the rounding of the timeouts handed to Playwright and the granularity of timers. */
 const DEADLINE_SLACK_MS = 5;
 let tail = Promise.resolve();
+/** The configured proxy as Chromium's server setting; the message never repeats the value, which may hold credentials. */
+function proxyServer(value) {
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch { /* Reported below. */ }
+    if (!url || !['http:', 'socks5:'].includes(url.protocol) || !url.hostname || url.username || url.password
+        || !['', '/'].includes(url.pathname) || url.search || url.hash) {
+        throw new TypeError('Browser proxy must be an http:// or socks5:// host and port');
+    }
+    return `${url.protocol}//${url.host}`;
+}
 export async function withLocalBrowser(options, run) {
     const { provider, timeoutMs } = options;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60_000) {
         throw new TypeError('Browser tracking timeout must be between 1 and 60000 ms');
     }
+    const proxy = options.proxy ? proxyServer(options.proxy) : null;
     options.signal?.throwIfAborted();
     const deadline = performance.now() + timeoutMs;
     const expiry = AbortSignal.timeout(Math.max(1, Math.floor(timeoutMs)));
@@ -56,7 +70,7 @@ export async function withLocalBrowser(options, run) {
             throw stopped();
         // Do not pass the application environment (database or API secrets) to Chromium.
         launching = chromium.launch({ executablePath: options.executablePath, headless: true, args: [...(options.args ?? [])],
-            timeout: Math.min(remainingMs(), 10_000),
+            timeout: Math.min(remainingMs(), 10_000), ...(proxy ? { proxy: { server: proxy } } : {}),
             env: { PATH: process.env.PATH ?? '', HOME: process.env.HOME ?? '/tmp', LANG: 'en_US.UTF-8' } });
         browser = await unlessStopped(launching);
         return await unlessStopped(run({ browser, signal, remainingMs }));

package/dist/data/catalog.json

@@ -6376,10 +6376,23 @@
         "timezone": "Europe/Madrid",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "gls-es",
+            "requirements": [
+                {
+                    "field": "postcode",
+                    "validator": "internationalPostcode",
+                    "label": "Delivery postcode",
+                    "type": "text",
+                    "help": "GLS Spain shows a shipment only with its delivery postcode.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
+                    "autoComplete": "postal-code"
+                }
+            ]
         },
         "canaryUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-        "trackingUrlTemplate": "https://mygls.gls-spain.es/e/?codigo={trackingNumber}",
+        "trackingUrlTemplate": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
         "trackingSearchUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
         "linkRules": [
             {
@@ -6391,6 +6404,12 @@
                     "codigo"
                 ]
             },
+            {
+                "domains": [
+                    "mygls.gls-spain.es"
+                ],
+                "path": "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$"
+            },
             {
                 "domains": [
                     "gls-group.com",

package/dist/generated/catalog.d.ts

@@ -4321,15 +4321,29 @@ export declare const CARRIER_CATALOG: {
         readonly timezone: "Europe/Madrid";
         readonly tracking: {
             readonly mode: "automatic";
-            readonly adapter: "universal";
+            readonly adapter: "gls-es";
+            readonly requirements: readonly [{
+                readonly field: "postcode";
+                readonly validator: "internationalPostcode";
+                readonly label: "Delivery postcode";
+                readonly type: "text";
+                readonly help: "GLS Spain shows a shipment only with its delivery postcode.";
+                readonly pattern: "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$";
+                readonly maxLength: 12;
+                readonly inputMode: "text";
+                readonly autoComplete: "postal-code";
+            }];
         };
         readonly canaryUrl: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/";
-        readonly trackingUrlTemplate: "https://mygls.gls-spain.es/e/?codigo={trackingNumber}";
+        readonly trackingUrlTemplate: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/";
         readonly trackingSearchUrl: "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/";
         readonly linkRules: readonly [{
             readonly domains: readonly ["mygls.gls-spain.es"];
             readonly pathPattern: "^/e/?$";
             readonly params: readonly ["codigo"];
+        }, {
+            readonly domains: readonly ["mygls.gls-spain.es"];
+            readonly path: "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$";
         }, {
             readonly domains: readonly ["gls-group.com", "gls-group.eu"];
             readonly pathPattern: "^/ES/";

package/dist/generated/catalog.js

@@ -6377,10 +6377,23 @@ export const CARRIER_CATALOG = {
         "timezone": "Europe/Madrid",
         "tracking": {
             "mode": "automatic",
-            "adapter": "universal"
+            "adapter": "gls-es",
+            "requirements": [
+                {
+                    "field": "postcode",
+                    "validator": "internationalPostcode",
+                    "label": "Delivery postcode",
+                    "type": "text",
+                    "help": "GLS Spain shows a shipment only with its delivery postcode.",
+                    "pattern": "^(?=.{3,12}$)(?=.*[0-9])[A-Za-z0-9]+(?:[ \\-][A-Za-z0-9]+)*$",
+                    "maxLength": 12,
+                    "inputMode": "text",
+                    "autoComplete": "postal-code"
+                }
+            ]
         },
         "canaryUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
-        "trackingUrlTemplate": "https://mygls.gls-spain.es/e/?codigo={trackingNumber}",
+        "trackingUrlTemplate": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
         "trackingSearchUrl": "https://gls-group.com/ES/es/recibir-paquetes/seguimiento-envio/",
         "linkRules": [
             {
@@ -6392,6 +6405,12 @@ export const CARRIER_CATALOG = {
                     "codigo"
                 ]
             },
+            {
+                "domains": [
+                    "mygls.gls-spain.es"
+                ],
+                "path": "^/e/([A-Za-z0-9]{5,40})/[^/?#]+(?:/[a-z]{2})?/?$"
+            },
             {
                 "domains": [
                     "gls-group.com",

package/dist/generated/registry.js

@@ -62,6 +62,7 @@ import { adapter as genikiTaxydromiki } from '../carriers/geniki-taxydromiki/ada
 import { adapter as geodis } from '../carriers/geodis/adapter.js';
 import { adapter as glsCh } from '../carriers/gls-ch/adapter.js';
 import { adapter as glsDe } from '../carriers/gls-de/adapter.js';
+import { adapter as glsEs } from '../carriers/gls-es/adapter.js';
 import { adapter as glsFr } from '../carriers/gls-fr/adapter.js';
 import { adapter as glsIt } from '../carriers/gls-it/adapter.js';
 import { adapter as gofo } from '../carriers/gofo/adapter.js';
@@ -206,6 +207,7 @@ export const REGISTRY = {
         "geodis": geodis,
         "gls-ch": glsCh,
         "gls-de": glsDe,
+        "gls-es": glsEs,
         "gls-fr": glsFr,
         "gls-it": glsIt,
         "gofo": gofo,
@@ -375,7 +377,7 @@ export const REGISTRY = {
         "geodis": "geodis",
         "gls-ch": "gls-ch",
         "gls-de": "gls-de",
-        "gls-es": "universal",
+        "gls-es": "gls-es",
         "gls-fr": "gls-fr",
         "gls-it": "gls-it",
         "go-express": "universal",

package/dist/server/openapi.json

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

package/package.json

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