universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/ups/status.d.ts

@@ -0,0 +1,25 @@
+/**
+ * UPS status vocabulary.
+ *
+ * UPS answers with two things: `progressBarType`, a short machine token on the
+ * shipment detail, and English prose (`packageStatus`, `simplifiedText`, the
+ * milestone name, the activity scans). The token is the stable key and is
+ * mapped first; the prose is matched on substrings because UPS localizes and
+ * re-words it freely and the same page mixes several phrasings for one state.
+ *
+ * The map produces a result-level `CarrierStatus`. UPS activities carry no
+ * stable per-event code, so the adapter attaches no `stage` to an event: the
+ * sync classifies the raw wording and records it for review instead.
+ */
+import type { CarrierStatus } from '../../core/result/index.js';
+/**
+ * Classify UPS status prose. `hasEvents` reports that the shipment already has
+ * a scan history, which is what makes unrecognized wording "moving" rather
+ * than "unknown"; without it an unmapped phrase stays `unknown` on purpose.
+ */
+export declare function upsStatus(text: string, hasEvents?: boolean): CarrierStatus;
+/**
+ * `progressBarType` on a shipment detail, lowercased. It outranks the prose
+ * because it is the value the page's own progress bar is driven by.
+ */
+export declare const UPS_PROGRESS_STATUS: Readonly<Record<string, CarrierStatus>>;

package/dist/carriers/ups/status.js

@@ -0,0 +1,41 @@
+const EXCEPTION_TERMS = [
+    'return to sender', 'returned', 'delivery attempted', 'we missed you',
+    'not delivered', 'exception', 'action required',
+];
+const DELIVERED_TERMS = ['delivered', 'left at'];
+const IN_TRANSIT_TERMS = [
+    'on the way', 'in transit', 'we have your package', 'first ups possession',
+    'departed', 'arrived', 'processing at ups facility',
+];
+const PENDING_TERMS = ['label created', 'manifest upload', 'shipment ready for ups'];
+/**
+ * Classify UPS status prose. `hasEvents` reports that the shipment already has
+ * a scan history, which is what makes unrecognized wording "moving" rather
+ * than "unknown"; without it an unmapped phrase stays `unknown` on purpose.
+ */
+export function upsStatus(text, hasEvents = false) {
+    const value = text.toLocaleLowerCase('en-US');
+    if (EXCEPTION_TERMS.some((term) => value.includes(term)))
+        return 'exception';
+    if (DELIVERED_TERMS.some((term) => value.includes(term)))
+        return 'delivered';
+    if (value.includes('out for delivery'))
+        return 'out_for_delivery';
+    if (hasEvents || IN_TRANSIT_TERMS.some((term) => value.includes(term)))
+        return 'in_transit';
+    if (PENDING_TERMS.some((term) => value.includes(term)))
+        return 'pending';
+    return 'unknown';
+}
+/**
+ * `progressBarType` on a shipment detail, lowercased. It outranks the prose
+ * because it is the value the page's own progress bar is driven by.
+ */
+export const UPS_PROGRESS_STATUS = {
+    manifestupload: 'pending',
+    firstupspossession: 'in_transit',
+    intransit: 'in_transit',
+    outfordelivery: 'out_for_delivery',
+    delivered: 'delivered',
+    exception: 'exception',
+};

package/dist/carriers/ups/statuses.json

@@ -0,0 +1,35 @@
+{
+  "carrier": "ups",
+  "entries": [
+    { "code": "ManifestUpload", "language": "en", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "progressBarType; the shipper announced the parcel electronically." },
+    { "code": "FirstUPSPossession", "language": "en", "stage": "accepted", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "progressBarType; the adapter reports the result status in_transit." },
+    { "code": "InTransit", "language": "en", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "progressBarType." },
+    { "code": "OutForDelivery", "language": "en", "stage": "out_for_delivery", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "progressBarType; exercised by fixtures/out-for-delivery.json." },
+    { "code": "Delivered", "language": "en", "stage": "delivered", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "progressBarType." },
+    { "code": "Exception", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "progressBarType; UPS's generic exception token. The adapter reports the result status exception without deciding between a failed attempt and a return." },
+    { "wording": "Return to Sender", "language": "en", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Returned", "language": "en", "stage": "returned", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Delivery Attempted", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "We Missed You", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Not Delivered", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Exception", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Action Required", "language": "en", "stage": "failed_attempt", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: exception." },
+    { "wording": "Delivered", "language": "en", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "Left at", "language": "en", "stage": "delivered", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Prefix of UPS's \"Left at: Front Door\" wording; the location detail itself is never retained." },
+    { "wording": "Out For Delivery", "language": "en", "stage": "out_for_delivery", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Seen as \"Out For Delivery Today\" in fixtures/out-for-delivery.json." },
+    { "wording": "On the Way", "language": "en", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "In Transit", "language": "en", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "We Have Your Package", "language": "en", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "First UPS Possession", "language": "en", "stage": "accepted", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "Adapter result status: in_transit." },
+    { "wording": "Departed", "language": "en", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Seen as \"Departed from Facility\"." },
+    { "wording": "Arrived", "language": "en", "stage": "in_transit", "confirmedBy": "fixture", "firstSeen": "2026-09-12", "note": "Seen as \"Arrived at Facility\"." },
+    { "wording": "Processing at UPS Facility", "language": "en", "stage": "in_transit", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "Label Created", "language": "en", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "Manifest Upload", "language": "en", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "Shipment Ready for UPS", "language": "en", "stage": "pending", "confirmedBy": "prior-art", "firstSeen": "2026-09-12", "note": "" },
+    { "wording": "Drop-Off", "language": "en", "stage": "accepted", "confirmedBy": "live", "firstSeen": "2026-09-15", "note": "Activity scan: the sender handed the parcel in at an access point. Resolved by the shared classifier because UPS activities carry no stage." },
+    { "wording": "The UPS Access Point™ location has prepared the package for return to UPS or pickup by UPS.", "language": "en", "stage": "accepted", "confirmedBy": "live", "firstSeen": "2026-09-15", "note": "Seen right after Drop-Off, while the progress bar still reads FirstUPSPossession. UPS uses the same sentence when an uncollected parcel goes back, where the later return scans decide the stage." },
+    { "wording": "Pickup Scan", "language": "en", "stage": "accepted", "confirmedBy": "live", "firstSeen": "2026-09-16", "note": "Activity scan: UPS collected the parcel. Resolved by the shared classifier." },
+    { "wording": "Delivered to UPS Access Point™ location and awaiting customer pickup.", "language": "en", "stage": "ready_for_pickup", "confirmedBy": "prior-art", "firstSeen": "2026-09-20", "note": "Checked before the delivered wording, which the sentence also contains." }
+  ]
+}

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

@@ -0,0 +1,25 @@
+import type { AdapterFactory } 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 normalizeUSPSNumber(raw: string): string;
+export declare function uspsTrackingUrl(trackingNumber: string): string;
+/** The server-rendered tracking page. */
+export declare function parseUSPSTrackingHtml(page: string, trackingNumber: string): CarrierResult;
+export interface USPSTrackerOptions {
+    timeoutMs?: number;
+    /** Legacy configuration seam; `trawl` is preferred. */
+    trawlUrl?: string;
+    /** The browser service, or null when none is configured. */
+    trawl?: TrawlClient | null;
+    fetcher?: typeof fetch;
+    recorder?: StepRecorder;
+}
+export declare class USPSTracker {
+    #private;
+    readonly timeoutMs: number;
+    readonly trawlUrl: string;
+    constructor(options?: USPSTrackerOptions);
+    fetch(trackingNumber: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/usps/adapter.js

@@ -0,0 +1,261 @@
+import { DateTime } from 'luxon';
+import { load } from 'cheerio';
+import { isValidS10TrackingNumber } from '../../core/detection/s10.js';
+import { ChallengeError, SchemaError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { usStateTimeZone } from '../../core/time/index.js';
+import { clean, TrawlClient } from '../../core/transport/index.js';
+import { uspsStage, uspsStatus } from './status.js';
+/**
+ * USPS, through the server-rendered tracking page.
+ *
+ * The page at `go/TrackConfirmAction?tLabels=` carries the verdict, the
+ * status and the history in its own HTML: no tracking XHR exists to capture.
+ * Plain HTTP probes returned 403. Browser checks on 2026-09-22 first returned
+ * a challenge shell, then succeeded with matching shipment timelines. Access
+ * can vary by session. The lookup has a single
+ * step: the private browser service loads the page, and the rendered DOM is
+ * parsed. Nothing is ever replayed over plain HTTP.
+ *
+ * Markup provenance: the live page shell (`.track-bar-container`,
+ * `#trackingNum`, `.latest-update-banner-wrapper .banner-header`,
+ * `.current-tracking-status-wrapper`), inspected 2026-09-20. Positive lookups
+ * on 2026-09-22 use `.tb-step` timeline cards, including collapsed history.
+ * The older table-shaped fixture remains a parsing fallback.
+ */
+const TRACKING_BASE = 'https://tools.usps.com/go/TrackConfirmAction';
+const MAX_BYTES = 10_000_000;
+const DEFAULT_TIMEOUT_MS = 90_000;
+const MAX_EVENTS_TO_RETURN = 100;
+export function normalizeUSPSNumber(raw) {
+    const value = raw.toLocaleUpperCase('en-US').replace(/[\s.-]/g, '');
+    // The S10 suffix identifies the issuing country, not the destination.
+    // Incoming international mail keeps that number when USPS takes over.
+    if (!/^\d{20}$/.test(value) && !/^\d{22}$/.test(value) && !isValidS10TrackingNumber(value)) {
+        throw new SchemaError('USPS', 'USPS tracking numbers must contain 20 or 22 digits, or be a checksum-valid UPU S10 number');
+    }
+    return value;
+}
+export function uspsTrackingUrl(trackingNumber) {
+    const url = new URL(TRACKING_BASE);
+    url.searchParams.set('tLabels', normalizeUSPSNumber(trackingNumber));
+    return url.toString();
+}
+const MONTHS = '(January|February|March|April|May|June|July|August|September|October|November|December)';
+const DATE_PATTERN = new RegExp(`${MONTHS}\\s+\\d{1,2},?\\s+\\d{4}`, 'i');
+const TIME_PATTERN = /\d{1,2}:\d{2}(?::\d{2})?\s*[ap]\.?m\.?/i;
+const STATE_PATTERN = /,\s*([A-Z]{2})\b/;
+function eventTime(dateText, timeText, location) {
+    const dateMatch = DATE_PATTERN.exec(dateText);
+    const timeMatch = TIME_PATTERN.exec(timeText);
+    if (!dateMatch || !timeMatch)
+        return null;
+    // Facility-local wall time lives in the event's own state.
+    const zone = usStateTimeZone(STATE_PATTERN.exec(location)?.[1]);
+    if (!zone)
+        return null;
+    const date = DateTime.fromFormat(dateMatch[0], 'MMMM d, yyyy', { locale: 'en-US', zone });
+    const time = DateTime.fromFormat(timeMatch[0].replace(/\./g, '').toLowerCase(), 'h:mm a', { locale: 'en-US', zone })
+        ?? DateTime.fromFormat(timeMatch[0].replace(/\./g, '').toLowerCase(), 'h:mm:ss a', { locale: 'en-US', zone });
+    if (!date.isValid || !time.isValid)
+        return null;
+    const at = date.set({ hour: time.hour, minute: time.minute, second: time.second });
+    const iso = at.toISO({ suppressMilliseconds: true });
+    return iso ? { iso, timestamp: at.toMillis() } : null;
+}
+/** A delivery estimate reduced to its calendar day. */
+function expectedDelivery(text) {
+    const match = /(?:expected|scheduled|anticipated)\s+delivery.*?([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})/is.exec(text);
+    if (!match)
+        return null;
+    const day = DateTime.fromFormat(match[1], 'MMMM d, yyyy', { locale: 'en-US', zone: 'utc' });
+    return day.isValid ? day.toISODate() : null;
+}
+function notLocated() {
+    return {
+        status: 'unknown',
+        last_status_text: 'USPS could not locate the shipment',
+        last_update: null,
+        expected_delivery: null,
+        events: [],
+    };
+}
+/** One history row, read by content pattern: a US date, a clock time, a
+ * city/state location, and the longest remaining cell as the description. */
+function parseRow(cells, index) {
+    const texts = cells.map((cell) => clean(cell, 500)).filter(Boolean);
+    if (texts.length < 2)
+        return null;
+    const dateText = texts.find((text) => DATE_PATTERN.test(text)) ?? '';
+    const timeText = texts.find((text) => TIME_PATTERN.test(text)) ?? '';
+    // The description cell can echo the location; the location cell is the
+    // shortest state-bearing one that carries no date.
+    const location = texts
+        .filter((text) => STATE_PATTERN.test(text) && !DATE_PATTERN.test(text))
+        .sort((left, right) => left.length - right.length)[0] ?? '';
+    const description = texts
+        .filter((text) => text !== dateText && text !== timeText && text !== location)
+        .sort((left, right) => right.length - left.length)[0] ?? '';
+    if (!description)
+        return null;
+    const at = eventTime(dateText, timeText, location);
+    const stage = uspsStage(description) ?? undefined;
+    const rawTime = clean(dateText === timeText ? dateText : `${dateText} ${timeText}`, 64);
+    return {
+        event: {
+            ...(at ? { time: at.iso } : rawTime ? { time: rawTime } : {}),
+            ...(location ? { location: location.slice(0, 250) } : {}),
+            // A delivered line may name who signed; the event keeps the fact, not the name.
+            description: stage === 'delivered' ? 'Delivered' : description,
+            ...(stage ? { stage } : {}),
+        },
+        timestamp: at?.timestamp ?? Number.NEGATIVE_INFINITY,
+        index,
+    };
+}
+/** Current USPS markup includes collapsed scans in the DOM, without a table.
+ * Undated progress steps and the history-expansion control are not scans. */
+function parseTimelineRow(description, dateText, location) {
+    if (!description || !DATE_PATTERN.test(dateText))
+        return null;
+    const stage = uspsStage(description) ?? undefined;
+    const at = eventTime(dateText, dateText, location);
+    const date = DATE_PATTERN.exec(dateText)?.[0];
+    const time = TIME_PATTERN.exec(dateText)?.[0];
+    // UTC is only a parsing frame here. An unresolved location gets an offset-free
+    // local_time, never a made-up UTC scan or another facility's timezone.
+    const local = date && time ? DateTime.fromFormat(`${date.replace(/,\s*/, ' ')} ${time.replace(/\./g, '').replace(/\s*([ap])m/i, ' $1m')}`, time.split(':').length === 3 ? 'MMMM d yyyy h:mm:ss a' : 'MMMM d yyyy h:mm a', { locale: 'en-US', zone: 'UTC' }) : null;
+    return {
+        ...(at ? { time: at.iso } : local?.isValid ? { local_time: local.toFormat("yyyy-MM-dd'T'HH:mm:ss") } : {}),
+        ...(!at && !local?.isValid ? { raw_time: dateText } : {}),
+        ...(location ? { location: location.slice(0, 250) } : {}),
+        description: stage === 'delivered' ? 'Delivered' : description,
+        ...(stage ? { stage } : {}),
+    };
+}
+/** The server-rendered tracking page. */
+export function parseUSPSTrackingHtml(page, trackingNumber) {
+    const number = normalizeUSPSNumber(trackingNumber);
+    const $ = load(page);
+    $('script, style, noscript').remove();
+    if ($('.track-bar-container').length === 0) {
+        throw new ChallengeError('USPS', 'USPS challenged the browser tracking session');
+    }
+    const echoed = clean($('#trackingNum').first().text()).toLocaleUpperCase('en-US');
+    if (echoed !== number) {
+        throw new SchemaError('USPS', 'USPS did not return the requested parcel');
+    }
+    // The page reuses .banner-header for an upsell banner; only the verdict
+    // wrapper carries the tracking verdict.
+    const banner = clean($('.latest-update-banner-wrapper .banner-header').first().text());
+    if (/tracking not available/i.test(banner))
+        return notLocated();
+    const current = $('.current-tracking-status-wrapper .current-step').first();
+    const statusArea = clean(current.find('.tb-status-detail').first().text()
+        || current.find('.tb-status').first().text()
+        || $('.current-tracking-status-wrapper').first().text(), 5_000);
+    const timeline = [];
+    $('.current-tracking-status-wrapper .tb-step').each((_, row) => {
+        const parsed = parseTimelineRow(clean($(row).find('.tb-status-detail').first().text(), 500), clean($(row).find('.tb-date').first().text(), 100), clean($(row).find('.tb-location').first().text(), 250));
+        if (parsed)
+            timeline.push(parsed);
+    });
+    const rows = [];
+    $('.tracking_history_container tr').each((index, row) => {
+        const cells = $(row).find('td').map((_, cell) => $(cell).text()).get();
+        if (cells.length === 0)
+            return;
+        const parsed = parseRow(cells, index);
+        if (parsed)
+            rows.push(parsed);
+    });
+    rows.sort((left, right) => right.timestamp - left.timestamp || left.index - right.index);
+    // The current timeline is newest-first. Keep its order even when some scans
+    // have no resolvable timezone; sorting those behind dated scans loses meaning.
+    const events = timeline.length ? timeline.slice(0, MAX_EVENTS_TO_RETURN)
+        : rows.slice(0, MAX_EVENTS_TO_RETURN).map(({ event }) => event);
+    const statusText = statusArea || banner || events[0]?.description || 'Tracking information received';
+    const stage = uspsStage(`${statusText} ${banner}`)
+        ?? events.map((event) => event.stage).find((value) => value !== undefined);
+    const status = uspsStatus(`${statusText} ${banner}`, events.length > 0);
+    const delivered = stage === 'delivered';
+    return {
+        status,
+        ...(stage ? { current_stage: stage } : {}),
+        last_status_text: delivered ? 'Delivered' : statusText,
+        last_update: events[0]?.time || null,
+        ...(events[0]?.local_time ? { last_update_local: events[0].local_time } : {}),
+        expected_delivery: delivered ? null : expectedDelivery(`${statusArea} ${banner}`),
+        events,
+    };
+}
+export class USPSTracker {
+    timeoutMs;
+    trawlUrl;
+    #trawl;
+    #fetcher;
+    #recorder;
+    constructor(options = {}) {
+        if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+            throw new TypeError('USPS timeout must be positive');
+        }
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.trawlUrl = (options.trawlUrl ?? '').trim();
+        this.#trawl = options.trawl;
+        this.#fetcher = options.fetcher;
+        this.#recorder = options.recorder ?? NOOP_RECORDER;
+    }
+    /** The injected browser service, or one built from the configured URL. */
+    #browserService() {
+        if (this.#trawl !== undefined)
+            return this.#trawl;
+        return this.trawlUrl ? new TrawlClient(this.trawlUrl, this.#fetcher) : null;
+    }
+    async fetch(trackingNumber) {
+        const number = normalizeUSPSNumber(trackingNumber);
+        // Akamai refuses every non-browser client, so a direct attempt only burns
+        // time. There is one step, and it is the browser.
+        const trawl = this.#browserService();
+        if (!trawl) {
+            throw new ChallengeError('USPS', 'USPS challenged direct tracking; configure FLARESOLVERR_URL for browser fallback');
+        }
+        return runSteps({
+            carrier: 'usps', budgetMs: this.timeoutMs, recorder: this.#recorder,
+        }, [
+            { id: 'trawl', run: () => this.#trawlResult(trawl, number) },
+        ]);
+    }
+    /** Read the browser's rendered page without replaying its session. An
+     * unresolved challenge remains an error so universal fallback can run. */
+    async #trawlResult(trawl, number) {
+        const page = await trawl.scrape({
+            url: uspsTrackingUrl(number),
+            skipHttp: true,
+            maxTier: 3,
+            maxTimeout: this.timeoutMs,
+        }, {
+            provider: 'TRAWL while fetching USPS',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_BYTES,
+            fetcher: this.#fetcher,
+        });
+        const result = parseUSPSTrackingHtml(page.html, number);
+        result.tracking_url = uspsTrackingUrl(number);
+        result.tracking_source = 'rendered-page';
+        return result;
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new USPSTracker({
+        fetcher: environment.fetcher,
+        trawl: environment.trawl,
+        recorder: environment.recorder,
+    });
+    return {
+        id: 'usps',
+        // Akamai refuses every non-browser client, so there is no direct tier.
+        steps: ['trawl'],
+        track: (input) => tracker.fetch(input.number),
+    };
+};

package/dist/carriers/usps/carrier.json

@@ -0,0 +1,74 @@
+{
+  "id": "usps",
+  "displayName": "USPS",
+  "aliases": [
+    "United States Postal Service"
+  ],
+  "region": {
+    "countries": [
+      "US"
+    ]
+  },
+  "brand": {
+    "color": "#004b87"
+  },
+  "selectable": true,
+  "timezone": "UTC",
+  "tracking": {
+    "mode": "automatic",
+    "adapter": "usps",
+    "steps": [
+      "trawl"
+    ]
+  },
+  "capabilities": [
+    "history",
+    "location",
+    "eta"
+  ],
+  "portal": {
+    "url": "https://tools.usps.com/go/TrackConfirmAction?tLabels={trackingNumber}",
+    "canaryUrl": "https://www.usps.com/",
+    "shows": [
+      "status",
+      "history",
+      "eta",
+      "location"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "eta",
+      "location"
+    ],
+    "discarded": [
+      "signatory",
+      "delivery instructions",
+      "tracking plus upsells"
+    ],
+    "unavailable": []
+  },
+  "links": [
+    {
+      "domains": [
+        "tools.usps.com",
+        "usps.com"
+      ],
+      "params": [
+        "tLabels"
+      ]
+    }
+  ],
+  "detection": [
+    {
+      "id": "usps-1",
+      "pattern": "^\\d{20}$",
+      "confidence": "low"
+    },
+    {
+      "id": "usps-2",
+      "pattern": "^\\d{22}$",
+      "confidence": "low"
+    }
+  ]
+}