universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/australia-post/adapter.d.ts

@@ -0,0 +1,20 @@
+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';
+import { TrawlClient } from '../../core/transport/index.js';
+export declare function normalizeAustraliaPostNumber(raw: string): string;
+export declare function australiaPostTrackingUrl(raw: string): string;
+export declare function australiaPostApiUrl(raw: string): string;
+/** The one lookup entry and article must independently match the submitted reference. */
+export declare function parse(payload: unknown, trackingNumber: string): CarrierResult;
+export interface AustraliaPostTrackerOptions {
+    trawl: TrawlClient | null;
+    timeoutMs?: number;
+    recorder?: StepRecorder;
+}
+export declare class AustraliaPostTracker {
+    private readonly options;
+    constructor(options: AustraliaPostTrackerOptions);
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/australia-post/adapter.js

@@ -0,0 +1,175 @@
+import { BudgetExceededError, ChallengeError, InputRequiredError, NotFoundError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { explicitOffsetTime, epochMillisTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { australiaPostStatus } from './status.js';
+const PROVIDER = 'Australia Post';
+const DETAIL = 'https://auspost.com.au/mypost/track/details/';
+const API = 'https://digitalapi.auspost.com.au/shipments-gateway/v1/watchlist/shipments';
+const MAX_BYTES = 1_000_000;
+const TRANSPORT_ALLOWANCE_MS = 15_000;
+export function normalizeAustraliaPostNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^(?=.*\d)[A-Z0-9]{10,34}$/.test(number)) {
+        throw new InputRequiredError(PROVIDER, 'number', 'Australia Post requires a 10-to-34-character tracking number');
+    }
+    return number;
+}
+export function australiaPostTrackingUrl(raw) {
+    return `${DETAIL}${normalizeAustraliaPostNumber(raw)}`;
+}
+export function australiaPostApiUrl(raw) {
+    return `${API}?${new URLSearchParams({ trackingIds: normalizeAustraliaPostNumber(raw) })}`;
+}
+/** The one lookup entry and article must independently match the submitted reference. */
+export function parse(payload, trackingNumber) {
+    const number = normalizeAustraliaPostNumber(trackingNumber);
+    if (!Array.isArray(payload) || !payload.length || payload.length > 20 || payload.some((entry) => !isRecord(entry))) {
+        throw new SchemaError(PROVIDER, 'Australia Post returned an invalid tracking response');
+    }
+    const entries = payload.filter(isRecord).filter((entry) => Array.isArray(entry.trackingIds) && entry.trackingIds.includes(number));
+    if (entries.length !== 1)
+        throw new SchemaError(PROVIDER, 'Australia Post returned a different or ambiguous lookup');
+    const entry = entries[0];
+    if (entry.status === 400 && isRecord(entry.error) && entry.error.errorCode === 21
+        && entry.error.error === 'Invalid Tracking ID' && entry.error.status === 'Failed'
+        && entry.shipment === undefined)
+        throw new NotFoundError(PROVIDER);
+    if (entry.status !== 200 || !isRecord(entry.shipment) || entry.shipment.status !== 'Success') {
+        throw new SchemaError(PROVIDER, 'Australia Post could not confirm the shipment');
+    }
+    const shipment = entry.shipment;
+    if (typeof shipment.consignmentId !== 'string' || !shipment.consignmentId
+        || !Array.isArray(shipment.articles) || !shipment.articles.length || shipment.articles.length > 100
+        || shipment.articles.some((article) => !isRecord(article))) {
+        throw new SchemaError(PROVIDER, 'Australia Post returned invalid articles');
+    }
+    const articles = shipment.articles.filter(isRecord);
+    const matches = articles.filter((article) => article.articleId === number);
+    // A consignment can contain several independent deliveries. Only an exact
+    // article or a verified single-article consignment can produce one result.
+    const selected = matches.length === 1 ? matches[0]
+        : matches.length === 0 && shipment.consignmentId === number && articles.length === 1
+            ? articles[0] : null;
+    if (!selected)
+        throw new SchemaError(PROVIDER, 'Australia Post returned a different or ambiguous article');
+    if (typeof selected.articleId !== 'string' || !selected.articleId || !Array.isArray(selected.details)
+        || selected.details.length !== 1 || !isRecord(selected.details[0])) {
+        throw new SchemaError(PROVIDER, 'Australia Post returned invalid article details');
+    }
+    const details = selected.details[0];
+    if (details.articleId !== selected.articleId || details.consignmentId !== shipment.consignmentId) {
+        throw new SchemaError(PROVIDER, 'Australia Post returned mismatched article details');
+    }
+    if (!Array.isArray(details.events) || !details.events.length || details.events.length > 500) {
+        throw new SchemaError(PROVIDER, 'Australia Post returned incomplete tracking history');
+    }
+    const events = [];
+    const seen = new Set();
+    for (const raw of details.events) {
+        if (!isRecord(raw))
+            throw new SchemaError(PROVIDER, 'Australia Post returned an invalid event');
+        const offset = explicitOffsetTime(raw.localeDateTime);
+        const epoch = typeof raw.dateTime === 'number' && Number.isSafeInteger(raw.dateTime) && raw.dateTime > 100_000_000_000
+            ? epochMillisTime(raw.dateTime) : null;
+        if (offset && epoch && offset.timestamp !== epoch.timestamp)
+            throw new SchemaError(PROVIDER, 'Australia Post returned conflicting event dates');
+        const at = offset ?? epoch;
+        if (!at)
+            throw new SchemaError(PROVIDER, 'Australia Post returned an invalid event date');
+        const code = clean(raw.eventCode, 64);
+        const description = clean(raw.description);
+        const location = clean(raw.location, 200);
+        if (!description)
+            throw new SchemaError(PROVIDER, 'Australia Post returned an empty event');
+        const classified = australiaPostStatus(clean(raw.milestone), code);
+        const event = { time: at.iso,
+            description: classified?.stage === 'delivered' ? 'Delivered' : description,
+            ...(location ? { location } : {}), ...(classified ? { stage: classified.stage } : {}),
+            ...(/^[A-Z0-9_-]{1,64}$/.test(code) ? { provider_code: code } : {}),
+        };
+        const key = JSON.stringify([at.timestamp, event.description, location, code]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        events.push({ event, timestamp: at.timestamp });
+    }
+    events.sort((a, b) => b.timestamp - a.timestamp);
+    const summary = clean(selected.trackStatusOfArticle)
+        || (isRecord(selected.status) ? clean(selected.status.statusAttributeValue) : '');
+    if (!summary)
+        throw new SchemaError(PROVIDER, 'Australia Post returned no article status');
+    const status = australiaPostStatus(summary);
+    const deliveredAt = status?.status === 'delivered' ? events.find(({ event }) => event.stage === 'delivered')?.event.time : null;
+    // Summary modification/milestone timestamps are not scan times. In the
+    // observed reply they differed from the delivery event by about ten hours.
+    return {
+        status: status?.status ?? 'unknown', ...(status ? { current_stage: status.stage } : {}),
+        last_status_text: status?.status === 'delivered' ? 'Delivered' : summary,
+        last_update: events[0].event.time, expected_delivery: null,
+        ...(deliveredAt ? { delivered_at: deliveredAt } : {}), events: events.slice(0, 100).map(({ event }) => event),
+    };
+}
+export class AustraliaPostTracker {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeAustraliaPostNumber(raw);
+        const budgetMs = context.budgetMs ?? this.options.timeoutMs ?? 45_000;
+        if (!Number.isFinite(budgetMs) || budgetMs <= 0 || budgetMs > 60_000)
+            throw new TypeError('Australia Post budget must be between 1 and 60000 ms');
+        context.signal?.throwIfAborted();
+        if (budgetMs <= TRANSPORT_ALLOWANCE_MS)
+            throw new BudgetExceededError(PROVIDER, budgetMs);
+        const trawl = this.options.trawl;
+        if (!trawl)
+            throw new ChallengeError(PROVIDER, 'Australia Post requires the browser tracking service');
+        return runSteps({ carrier: 'australia-post', budgetMs, signal: context.signal, recorder: this.options.recorder }, [{
+                id: 'trawl', run: async ({ signal, remainingMs }) => {
+                    const timeoutMs = Math.floor(remainingMs - TRANSPORT_ALLOWANCE_MS);
+                    if (timeoutMs < 1)
+                        throw new BudgetExceededError(PROVIDER, budgetMs);
+                    const apiUrl = australiaPostApiUrl(number);
+                    const page = await trawl.scrape({ url: australiaPostTrackingUrl(number), skipHttp: true, maxTier: 3,
+                        maxTimeout: timeoutMs, captureResponses: [apiUrl], settleTimeout: Math.min(timeoutMs, 10_000),
+                    }, { provider: 'TRAWL while fetching Australia Post', timeoutMs, signal, maxBytes: 6_000_000, requireSolved: false });
+                    signal.throwIfAborted();
+                    if (![2, 3].includes(page.tier) || ![200, 304].includes(page.statusCode)) {
+                        throw new TransportError(PROVIDER, 'The browser service did not load Australia Post tracking');
+                    }
+                    const captures = page.capturedResponses.filter((capture) => capture.url === apiUrl && capture.status !== 204);
+                    if (!captures.length || captures.length > 20)
+                        throw new TransportError(PROVIDER, 'Australia Post returned no matching browser response');
+                    const capture = captures[captures.length - 1];
+                    if (capture.status === 429) {
+                        const retry = capture.headers['retry-after'];
+                        throw new RateLimitedError(PROVIDER, retry && /^\d+$/.test(retry) ? Number(retry) * 1000 : undefined);
+                    }
+                    if ([401, 403].includes(capture.status))
+                        throw new ChallengeError(PROVIDER);
+                    if (capture.status >= 400)
+                        throw new UpstreamHttpError(PROVIDER, capture.status);
+                    if (capture.status !== 200 || capture.error || capture.truncated || capture.base64Encoded || capture.body === null) {
+                        throw new TransportError(PROVIDER, 'Australia Post returned an incomplete browser response');
+                    }
+                    if (Buffer.byteLength(capture.body, 'utf8') > MAX_BYTES)
+                        throw new SchemaError(PROVIDER, 'Australia Post returned an unexpectedly large response');
+                    let payload;
+                    try {
+                        payload = JSON.parse(capture.body);
+                    }
+                    catch {
+                        throw new SchemaError(PROVIDER, 'Australia Post returned invalid tracking JSON');
+                    }
+                    return parse(payload, number);
+                },
+            }]);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new AustraliaPostTracker({ trawl: environment.trawl, recorder: environment.recorder });
+    return { id: 'australia-post', recordsSteps: true, steps: ['trawl'], track: (input, context) => tracker.fetch(input.number, context) };
+};

package/dist/carriers/australia-post/carrier.json

@@ -0,0 +1,72 @@
+{
+  "id": "australia-post",
+  "displayName": "Australia Post",
+  "aliases": [],
+  "region": {
+    "countries": [
+      "AU"
+    ]
+  },
+  "brand": {
+    "color": "#dc1928"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "australia-post",
+    "steps": [
+      "trawl"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "provider_code",
+    "delivered_at"
+  ],
+  "portal": {
+    "url": "https://auspost.com.au/mypost/track/details/{trackingNumber}",
+    "canaryUrl": "https://auspost.com.au/mypost/track/",
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "provider_code",
+      "delivered_at",
+      "recipient_name",
+      "address",
+      "delivery_proof"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "provider_code",
+      "delivered_at"
+    ],
+    "discarded": [
+      "recipient_name",
+      "address",
+      "delivery_proof"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "auspost.com.au"
+      ],
+      "params": [
+        "id"
+      ]
+    },
+    {
+      "domains": [
+        "auspost.com.au"
+      ],
+      "path": "^/mypost/track/details/([^/?#]+)/?$"
+    }
+  ],
+  "detection": []
+}

package/dist/carriers/australia-post/numbers.json

@@ -0,0 +1,66 @@
+{
+  "carrier": "australia-post",
+  "records": [
+    {
+      "number": "7T2514965601000935102",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://ie.trustpilot.com/reviews/6a90f17ecd0f0d3f7a9afab5",
+        "date": "2026-09-20"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified. Quoted in a merchant's reply. The source attributes it to Australia Post; no rule matches this shape."
+    },
+    {
+      "number": "0301006785462006320995",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/clooney/australia-post-tracking-api/blob/master/australia-post-tracking-api-python.md"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "austrian-post",
+          "usps",
+          "estafeta"
+        ]
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Australia Post, which no rule claims."
+    },
+    {
+      "number": "LH290032509AU",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/clooney/australia-post-tracking-api/blob/master/australia-post-tracking-api-python.md"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "intl-post",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Australia Post; detection falls back to the generic postal rule."
+    },
+    {
+      "number": "LK201223662AU",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/clooney/australia-post-tracking-api/blob/master/australia-post-tracking-api-python.md"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "intl-post",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Australia Post; detection falls back to the generic postal rule."
+    }
+  ]
+}

package/dist/carriers/australia-post/status.d.ts

@@ -0,0 +1,2 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function australiaPostStatus(label: string, code?: string): ClassifiedStatus | undefined;

package/dist/carriers/australia-post/status.js

@@ -0,0 +1,34 @@
+// Event codes and milestone labels consumed by the public tracking application.
+// statuses.json distinguishes live vocabulary from synthetic status boundaries.
+const CODES = {
+    'DD-ER15': { stage: 'delivered', status: 'delivered' },
+    'AFP-ER13': { stage: 'out_for_delivery', status: 'out_for_delivery' },
+    'TTP-ER81': { stage: 'in_transit', status: 'in_transit' },
+    'AFP-ER37': { stage: 'in_transit', status: 'in_transit' },
+    'NSS-ER42': { stage: 'in_transit', status: 'in_transit' },
+    'AFC-ER36': { stage: 'accepted', status: 'in_transit' },
+    'ADMIN-ER40': { stage: 'registered', status: 'pending' },
+    'ADMIN-ER39': { stage: 'registered', status: 'pending' },
+    'CE-SR05': { stage: 'registered', status: 'pending' },
+};
+const LABELS = {
+    'delivered': { stage: 'delivered', status: 'delivered' },
+    "it's coming today": { stage: 'out_for_delivery', status: 'out_for_delivery' },
+    'onboard for delivery': { stage: 'out_for_delivery', status: 'out_for_delivery' },
+    'out for delivery': { stage: 'out_for_delivery', status: 'out_for_delivery' },
+    "it's on its way": { stage: 'in_transit', status: 'in_transit' },
+    'in transit': { stage: 'in_transit', status: 'in_transit' },
+    "we've got it": { stage: 'accepted', status: 'in_transit' },
+    'label created by sender': { stage: 'registered', status: 'pending' },
+    'awaiting collection': { stage: 'ready_for_pickup', status: 'in_transit' },
+    'attempted delivery': { stage: 'failed_attempt', status: 'exception' },
+    'delayed': { stage: 'exception', status: 'exception' },
+    'return to sender': { stage: 'returned', status: 'exception' },
+    'returned to sender': { stage: 'returned', status: 'exception' },
+};
+export function australiaPostStatus(label, code) {
+    if (code && Object.hasOwn(CODES, code))
+        return CODES[code];
+    const key = label.trim().toLowerCase().replace(/’/g, "'");
+    return Object.hasOwn(LABELS, key) ? LABELS[key] : undefined;
+}

package/dist/carriers/australia-post/statuses.json

@@ -0,0 +1,172 @@
+{
+  "carrier": "australia-post",
+  "entries": [
+    {
+      "code": "DD-ER15",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "AFP-ER13",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "TTP-ER81",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "AFP-ER37",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "NSS-ER42",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "AFC-ER36",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "ADMIN-ER40",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "ADMIN-ER39",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "code": "CE-SR05",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Observed public shipment-gateway event code."
+    },
+    {
+      "wording": "Delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "It's coming today",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "It's on its way",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "We've got it",
+      "language": "en",
+      "stage": "accepted",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "Label created by sender",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "Onboard for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "firstSeen": "2026-09-26",
+      "note": "Exact public article milestone or event wording."
+    },
+    {
+      "wording": "Out for delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "In transit",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "Awaiting collection",
+      "language": "en",
+      "stage": "ready_for_pickup",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "Attempted delivery",
+      "language": "en",
+      "stage": "failed_attempt",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "Delayed",
+      "language": "en",
+      "stage": "exception",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "Return to sender",
+      "language": "en",
+      "stage": "returned",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    },
+    {
+      "wording": "Returned to sender",
+      "language": "en",
+      "stage": "returned",
+      "confirmedBy": "fixture",
+      "firstSeen": "2026-09-26",
+      "note": "Synthetic semantic boundary; not observed in the live reference."
+    }
+  ]
+}

package/dist/carriers/austrian-post/adapter.d.ts

@@ -0,0 +1,13 @@
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeAustrianPostNumber(raw: string): string;
+export declare function parseAustrianPostResponse(payload: unknown, rawNumber: string): CarrierResult;
+export declare class AustrianPostTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        timeoutMs?: number;
+    });
+    fetch(rawNumber: string, context?: TrackingContext): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/austrian-post/adapter.js

@@ -0,0 +1,101 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { isValidS10TrackingNumber, normalizeTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, NotFoundError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { austrianPostEventStatus, austrianPostSummaryStatus } from './status.js';
+const PROVIDER = 'Austrian Post';
+// Published in the official tracking form's data-sendungsapiurlpublic attribute;
+// the official client calls this read without the optional account token.
+const ENDPOINT = 'https://api.post.at/sendungen/sv/graphqlPublic';
+export function normalizeAustrianPostNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!/^\d{22}$/.test(number) && !(/^[A-Z]{2}\d{9}AT$/.test(number) && isValidS10TrackingNumber(number))) {
+        throw new TypeError('Austrian Post requires a 22-digit or valid AT postal identifier');
+    }
+    return number;
+}
+export function parseAustrianPostResponse(payload, rawNumber) {
+    const number = normalizeAustrianPostNumber(rawNumber);
+    if (!isRecord(payload))
+        throw new SchemaError(PROVIDER);
+    if (Array.isArray(payload.errors) && payload.errors.length)
+        throw new IndeterminateError(PROVIDER, 'Austrian Post could not complete its tracking query');
+    if (!isRecord(payload.data) || !Object.hasOwn(payload.data, 'einzelsendung'))
+        throw new SchemaError(PROVIDER);
+    const parcel = payload.data.einzelsendung;
+    // This is the official client's positive not-found signature.
+    if (parcel === null)
+        throw new NotFoundError(PROVIDER);
+    if (!isRecord(parcel) || clean(parcel.sendungsnummer, 64) !== number)
+        throw new SchemaError(PROVIDER, 'Austrian Post returned a different shipment');
+    if (!Array.isArray(parcel.sendungsEvents) || parcel.sendungsEvents.length > 500)
+        throw new SchemaError(PROVIDER, 'Austrian Post returned invalid tracking history');
+    const parsed = [];
+    const seen = new Set();
+    parcel.sendungsEvents.forEach((raw, index) => {
+        if (!isRecord(raw))
+            throw new SchemaError(PROVIDER, 'Austrian Post returned an invalid scan');
+        const time = explicitOffsetTime(raw.timestamp);
+        const description = clean(raw.trackingDesc, 500);
+        if (!time || !description)
+            throw new SchemaError(PROVIDER, 'Austrian Post returned an incomplete scan');
+        const location = clean(raw.eventPlaceName, 200);
+        const mapped = austrianPostEventStatus(clean(raw.status, 32), clean(raw.reasontypecode, 32), description);
+        const key = JSON.stringify([time.iso, location, description]);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        parsed.push({ event: { time: time.iso, description, ...(location ? { location } : {}), ...(mapped ? { stage: mapped.stage } : {}) }, timestamp: time.timestamp, index });
+    });
+    parsed.sort((a, b) => b.timestamp - a.timestamp || b.index - a.index);
+    const events = parsed.slice(0, 100).map(({ event }) => event);
+    const mapped = austrianPostSummaryStatus(clean(parcel.status, 32));
+    if (!events.length)
+        throw new IndeterminateError(PROVIDER, 'Austrian Post returned a shipment without tracking history');
+    const weight = typeof parcel.weight === 'number' && Number.isFinite(parcel.weight) && parcel.weight > 0 ? parcel.weight : null;
+    return {
+        status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        last_status_text: events[0].description, last_update: events[0].time, expected_delivery: null,
+        ...(weight === null ? {} : { weight_kg: weight }), events,
+    };
+}
+export class AustrianPostTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(rawNumber, context = {}) {
+        const number = normalizeAustrianPostNumber(rawNumber);
+        const budgetMs = context.budgetMs ?? this.options.timeoutMs ?? 15_000;
+        if (!Number.isFinite(budgetMs) || budgetMs <= 0)
+            throw new TypeError('Austrian Post timeout must be positive');
+        context.signal?.throwIfAborted();
+        const query = `query { einzelsendung(sendungsnummer: "${number}") { sendungsnummer status weight sendungsEvents { timestamp status reasontypecode trackingDesc eventPlaceName } } }`;
+        try {
+            const { bytes } = await fetchBounded(ENDPOINT, {
+                method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ query }),
+            }, {
+                provider: PROVIDER, maxBytes: 1_000_000, timeoutMs: Math.max(1, Math.floor(budgetMs)),
+                fetcher: (input, init) => (this.options.fetcher ?? fetch)(input, {
+                    ...init, signal: AbortSignal.any([...(context.signal ? [context.signal] : []), ...(init?.signal ? [init.signal] : [])]),
+                }),
+            });
+            context.signal?.throwIfAborted();
+            return parseAustrianPostResponse(parseJsonBytes(bytes, PROVIDER), number);
+        }
+        catch (error) {
+            if (error instanceof UpstreamHttpError && [404, 410].includes(error.status))
+                throw new TransportError(PROVIDER, 'Austrian Post tracking endpoint is unavailable', { cause: error });
+            throw error;
+        }
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new AustrianPostTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'austrian-post', steps: ['direct'], track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeAustrianPostNumber(number))),
+    };
+};