ts-server-lib 0.0.48

package/utils/TSRequest.js

@@ -0,0 +1,689 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSRequest = exports.FEED_XML_PARSER_WORKER_CONFIG = exports.FEED_XML_PARSER_DATA_OPTIONS = exports.feedXmlIsArray = exports.XML_WORKER_MAX_OLD_GEN_MB = exports.XML_WORKER_TASK_TIMEOUT_MS = exports.XML_OFFTHREAD_MIN_BYTES = void 0;
+exports.configureXmlParsing = configureXmlParsing;
+exports.getXmlParsingConfig = getXmlParsingConfig;
+exports.feedXmlParserOptions = feedXmlParserOptions;
+exports.buildFeedXmlParserOptions = buildFeedXmlParserOptions;
+exports.getXmlParseStats = getXmlParseStats;
+exports.resetXmlParseStatsForTests = resetXmlParseStatsForTests;
+exports.closeXmlWorkerPool = closeXmlWorkerPool;
+exports.parseXmlDocument = parseXmlDocument;
+exports.request = request;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const querystring_1 = require("querystring");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const abort_1 = require("./abort");
+/**
+ * Body size at or above which XML parsing is moved off the main thread.
+ *
+ * `fast-xml-parser` is synchronous and un-interruptible, so a large REST response blocks the event
+ * loop for the whole parse. Measured in a sports feed replay: a `matches` schedule sweep (~30 day
+ * schedules plus tournament schedules, one 16-tournament chunk holding 14,266 events) produced
+ * event-loop stalls of ~364 ms and periodic >1 s AMQP dispatch breaches on every `matches` cron minute.
+ * The AMQP path never had this problem because it already parses inside a TSRQW worker; only REST
+ * parsed inline.
+ *
+ * Below this size, offloading is a net loss: the structured-clone round-trip to a worker costs more
+ * than parsing a small document. Tuned to sit above ordinary API replies and below the multi-hundred-KB
+ * schedule documents that actually stall the loop.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
+ * 🔴 **128 KB -> 64 KB, 2026-08-14. The schedule documents were missing the worker by 2.8 KB.**
+ *
+ * The paragraph above predicted "multi-hundred-KB schedule documents". Measured, they are not: the largest
+ * inline document is **125.2 KB**, i.e. **2.8 KB under the old 128 KB cutoff**, so the exact population this
+ * threshold exists to offload was taking the inline path every time. The same near-miss was recorded once
+ * before at 130,676 bytes against 131,072 (396 bytes under) — twice is a pattern, not a coincidence: UOF
+ * schedule responses cluster just below 128 KB.
+ *
+ * Measured on the sports feed, 6,124 inline parses over one catalog window:
+ *
+ *     mean inline document     5.4 KB  ->  1.14 ms      <- thousands of small entity fetches
+ *     MAX  inline document   125.2 KB  ->    42 ms      <- the schedule documents
+ *     aggregate inline time    6,995 ms (~2 % duty)
+ *
+ * ⚠ **Do NOT size this from the mean.** 5.4 KB / 1.14 ms makes inline parsing look free, and that average is
+ * what hid the problem: it mixes two populations — many tiny documents that dominate the COUNT and a few large
+ * ones that dominate the COST. The relevant statistic is `inlineMaxMs` x caller concurrency.
+ *
+ * Why it mattered: the REST callers fetch N documents through one `Promise.all`, so N parses resolve
+ * back-to-back with no yield between them. At N=8 that is 8 x 42 ms = **336 ms** of un-yieldable main-thread
+ * time; observed `lagPeakMs` on those stages was 338 / 368 / 548 / 676 / 1,301 / 1,640 ms **with dispatch at
+ * zero**. The consuming service's background contract is a 4 ms cooperative slice, and a monolithic
+ * `XMLParser().parse()` cannot be sliced at all — so the only way background XML honours that contract is to
+ * leave this thread.
+ *
+ * 64 KB is chosen to move that population and nothing else: it is ~12x the 5.4 KB mean, so small documents keep
+ * the inline path where the round trip genuinely costs more than the parse. `TSRequestXml.spec.ts` already
+ * bounds this constant to [64 KB, 512 KB]; this sits at that floor deliberately.
+ *
+ * 🟢 **Safe for the money path by construction:** AMQP messages never reach this function — they parse inside a
+ * TSRQW worker pool (see the note above, and `threadFactor` in the atfeed betradar driver). Only REST does, and
+ * in the sports feed REST is exclusively the catalog/schedule sync, i.e. background work.
+ *
+ * Watch `offThread` count after this change: the pool is ONE worker, so if the 64-128 KB band turns out to hold
+ * thousands of documents rather than dozens they will serialise behind each other. That is still the right place
+ * for them — a queued worker does not block the loop — but it makes the catalog sweep slower, which is the
+ * trade being accepted here.
+ */
+/**
+ * DEFAULT threshold. The authority for this number is this library's own measurement,
+ * `test/utils/TSRequestXmlCrossover.spec.ts`, which measures the main-thread BLOCK per mode across a size
+ * ladder. Change it against that spec's output, not against reasoning: it has been wrong twice before, in
+ * opposite directions, both times from reasoning alone.
+ *
+ * Two specs constrain it and the effective bound is their INTERSECTION, [64 KB, 128 KB] —
+ * `TSRequestXml.spec.ts` asserts [64 KB, 512 KB], the crossover spec asserts [32 KB, 128 KB]. 64 KB therefore
+ * sits exactly on the floor: it cannot be lowered by editing this line alone, which is deliberate.
+ *
+ * A consumer that wants a different value sets it at startup with {@link configureXmlParsing} instead. That
+ * accepts a wider range on purpose — probing is a runtime question, while this constant is a shipped default —
+ * and it keeps the workload that justifies a change, and the record of it, in the service that measured it.
+ */
+exports.XML_OFFTHREAD_MIN_BYTES = 64 * 1024;
+/**
+ * Default ceiling for one off-thread parse. Generous next to a ~1 MB document (~250 ms measured), because
+ * firing it also retires the worker — see `TSRQWPoolOptions.taskTimeoutMs`.
+ */
+exports.XML_WORKER_TASK_TIMEOUT_MS = 30_000;
+/** Hard bounds on a configured threshold. A value outside these is a mistake, not a tuning choice. */
+const XML_OFFTHREAD_MIN_ALLOWED = 16 * 1024;
+const XML_OFFTHREAD_MAX_ALLOWED = 4 * 1024 * 1024;
+let xmlOffThreadMinBytes = exports.XML_OFFTHREAD_MIN_BYTES;
+let xmlWorkerTaskTimeoutMs = exports.XML_WORKER_TASK_TIMEOUT_MS;
+/**
+ * Override XML parsing behaviour for THIS process.
+ *
+ * The defaults above stay the measured-neutral values — 64 KB is the only threshold with evidence behind it
+ * (see {@link XML_OFFTHREAD_MIN_BYTES}), so a service that configures nothing gets exactly what was measured.
+ * This exists so a service can probe a different value from its OWN startup, without a library edit, a
+ * version bump across every consumer, or a hand-patched `node_modules` copy — all three of which were done
+ * on 2026-08-16 to test a single number.
+ *
+ * ⚠ Call this at startup, BEFORE the first large document is parsed. The worker pool is created lazily on
+ * first use and reads `workerTaskTimeoutMs` at construction, so a later change to the timeout applies only
+ * if the pool is rebuilt. `offThreadMinBytes` is read per call and takes effect immediately.
+ *
+ * Throws on an out-of-range or non-integer threshold rather than clamping: this value decides which parses
+ * hold the event loop, and a silently corrected one would misreport what a measurement actually ran.
+ */
+function configureXmlParsing(opts) {
+    if (opts.offThreadMinBytes !== undefined) {
+        const n = opts.offThreadMinBytes;
+        if (!Number.isInteger(n) || n < XML_OFFTHREAD_MIN_ALLOWED || n > XML_OFFTHREAD_MAX_ALLOWED) {
+            throw new Error(`configureXmlParsing: offThreadMinBytes must be an integer in ` +
+                `[${XML_OFFTHREAD_MIN_ALLOWED}, ${XML_OFFTHREAD_MAX_ALLOWED}], got ${String(n)}`);
+        }
+        xmlOffThreadMinBytes = n;
+    }
+    if (opts.workerTaskTimeoutMs !== undefined) {
+        const t = opts.workerTaskTimeoutMs;
+        if (!Number.isInteger(t) || t < 0) {
+            throw new Error(`configureXmlParsing: workerTaskTimeoutMs must be a non-negative integer, got ${String(t)}`);
+        }
+        xmlWorkerTaskTimeoutMs = t;
+    }
+}
+/** The values actually in force — report these with a measurement, never the defaults. */
+function getXmlParsingConfig() {
+    return { offThreadMinBytes: xmlOffThreadMinBytes, workerTaskTimeoutMs: xmlWorkerTaskTimeoutMs };
+}
+/**
+ * Old-generation ceiling for the single XML parse worker.
+ *
+ * Bounds a cost that was previously unbounded in two directions at once: an unbounded number of workers
+ * (see the pool construction) and an unbounded heap per worker. V8 does not return old-generation pages
+ * to the OS, so a long-lived worker's high-water mark IS the process's RSS for its lifetime.
+ *
+ * 192 MB is ~25x the parsed graph of the largest document observed (~1 MB of XML), so it is a runaway
+ * guard rather than a working limit. Raising it should be justified by `offThreadBytes / offThread`, not
+ * by a worker failure — a failure here degrades to inline parsing, it does not drop the document.
+ */
+exports.XML_WORKER_MAX_OLD_GEN_MB = 192;
+/**
+ * THE single definition of the feed `isArray` predicate: array-ify every non-attribute nested node.
+ *
+ * Everything else derives from this — including the worker copies, via
+ * {@link FEED_XML_PARSER_WORKER_CONFIG}. Do not restate this logic anywhere.
+ */
+const feedXmlIsArray = (_n, jPath, _l, isAttr) => !isAttr && String(jPath).includes('.');
+exports.feedXmlIsArray = feedXmlIsArray;
+/**
+ * Data-only fast-xml-parser options (structured-cloneable — no functions).
+ *
+ * These are the values the atfeed Betradar AMQP worker had been carrying locally, promoted here so
+ * every feed parse — REST and AMQP — shares one configuration and atfeed no longer overrides anything.
+ *
+ * `ignoreDeclaration: true` was the one genuine divergence: the AMQP worker set it, while
+ * `TSRequest.xml` and atfeed's own `recovery-request.ts` parser did not. Without it, a document with an
+ * `<?xml …?>` prolog yields an extra `?xml` key in the parsed object, so REST and AMQP produced
+ * different shapes for the same markup. Adopting the AMQP value drops that key from REST parses too —
+ * a deliberate behaviour change that makes the two paths agree. Nothing reads `?xml`; it is prolog
+ * metadata, not content.
+ */
+exports.FEED_XML_PARSER_DATA_OPTIONS = {
+    ignoreDeclaration: true,
+    ignoreAttributes: false,
+    attributeNamePrefix: '',
+    attributesGroupName: '$',
+    textNodeName: '_'
+};
+/**
+ * Canonical fast-xml-parser options for provider feed XML (REST **and** AMQP).
+ *
+ * Use this everywhere a feed document is parsed. Divergence between two parser configurations does not
+ * fail loudly — it silently changes the parsed shape, which for odds/settlement payloads means wrong
+ * market or outcome data rather than an error.
+ */
+function feedXmlParserOptions() {
+    return { ...exports.FEED_XML_PARSER_DATA_OPTIONS, isArray: exports.feedXmlIsArray };
+}
+/**
+ * Options for a worker that must rebuild the parser itself.
+ *
+ * A TSRQW callback is stringified into an eval worker, so it closes over nothing, and `isArray` is a
+ * function — which structured-clone cannot transfer. Passing the predicate's SOURCE keeps a single
+ * definition: the worker reconstructs it with {@link buildFeedXmlParserOptions} rather than restating
+ * the logic. Derived via `toString()` so the source can never drift from the function above.
+ *
+ * Pass this as TSRQW's `workerData` (or merge it into an existing `workerData`).
+ */
+exports.FEED_XML_PARSER_WORKER_CONFIG = {
+    ...exports.FEED_XML_PARSER_DATA_OPTIONS,
+    isArraySource: exports.feedXmlIsArray.toString()
+};
+/**
+ * Rebuild the canonical parser options inside a worker from {@link FEED_XML_PARSER_WORKER_CONFIG}.
+ *
+ * Safe to call from stringified worker code: it only needs the plain config object. `new Function` is
+ * used to revive the predicate — no additional risk in a context that is already an eval worker, and
+ * TSRQW's wrapper predefines `__name` for the same reason (bundlers inject it into `toString()` output).
+ */
+function buildFeedXmlParserOptions(cfg) {
+    const { isArraySource, ...data } = cfg;
+    const isArray = isArraySource
+        ?
+            new Function(`"use strict"; return (${isArraySource});`)()
+        : exports.feedXmlIsArray;
+    return { ...data, isArray };
+}
+let xmlPool = null;
+let xmlPoolUnavailable = false;
+/**
+ * Lazily create the shared XML parse pool.
+ *
+ * Returns null when a pool cannot be created (and remembers that, so we do not retry per request).
+ * Every caller must fall back to inline parsing in that case — an unavailable worker must never turn
+ * into a failed request.
+ */
+async function xmlWorkerPool() {
+    if (xmlPool)
+        return xmlPool;
+    if (xmlPoolUnavailable)
+        return null;
+    try {
+        // Imported lazily: TSRQW pulls in the Redis stack, and TSRequest must stay usable (and cheap) in
+        // processes that never parse a large XML document.
+        const { TSRQW } = await import('../db/TSRQW.js');
+        // Both arrows below must stay `async` even without an `await`: TSRQW calls the factory as
+        // `cb(workerData).then(fn => ...)` and each task as `fn(task).then(...)`, so both must return
+        // promises. Parsing itself is synchronous — that is the point; it happens on the worker thread.
+        /* eslint-disable @typescript-eslint/require-await -- TSRQW factory/handler contract is promise-based */
+        xmlPool = TSRQW.worker(async (wd) => {
+            /* eslint-disable @typescript-eslint/no-require-imports -- stringified into an eval worker; import() breaks under Vitest SSR */
+            const { XMLParser } = require('fast-xml-parser');
+            /* eslint-enable @typescript-eslint/no-require-imports */
+            // Rebuilt from the workerData config rather than restated here, so the predicate has exactly one
+            // definition (feedXmlIsArray) that both threads derive from. Inlined rather than imported because
+            // this callback is stringified into the worker and closes over nothing.
+            const cfg = (wd ?? {});
+            const { isArraySource, ...data } = cfg;
+            const isArray = isArraySource
+                ? new Function(`"use strict"; return (${isArraySource});`)()
+                : undefined;
+            const parser = new XMLParser({ ...data, ...(isArray ? { isArray } : {}) });
+            return async (task) => parser.parse(String(task?.body ?? ''));
+        }, 1, exports.FEED_XML_PARSER_WORKER_CONFIG, {
+            // ONE worker, stated as a number. `factor: 1` above reads like "one worker" and is TSRQW's
+            // default, but factor is a DIVISOR of the core count — so this pool silently ran
+            // availableParallelism() workers: 20 on the measured host, each with an unbounded V8 heap, each
+            // parsing ~1 MB schedule documents. RSS climbed 1,065 MB -> 2,015 MB while the main-thread heap
+            // stayed flat and GC'd normally, because `process.memoryUsage().heapUsed` does not see worker
+            // heaps. One thread is also the right number on merit: parses are serialised behind a single
+            // ~1 MB document anyway, and each extra thread is a whole V8 isolate.
+            threads: 1,
+            // A ceiling so this can never ratchet again, whatever the thread count. Generous next to a
+            // ~1 MB document's parsed graph, and overrun is survivable: the worker dies with
+            // ERR_WORKER_OUT_OF_MEMORY, TSRQW replaces it, and `parseXmlDocument` falls back to inline.
+            resourceLimits: { maxOldGenerationSizeMb: exports.XML_WORKER_MAX_OLD_GEN_MB },
+            // Bounds the ONE failure this fallback could not cover. Death by error or OOM rejects the task and
+            // degrades to inline; a worker that simply never replies did not, and with a single-worker pool that
+            // is not one lost document — the pool holds zero free workers and every later parse queues behind it
+            // forever. The timeout makes that case look like any other task failure.
+            taskTimeoutMs: xmlWorkerTaskTimeoutMs,
+            // Safe here because parsing is a PURE function: re-running it on a fresh worker cannot double a side
+            // effect, because there is none. Worth having even though this caller already degrades to inline —
+            // an inline retry moves the whole parse back onto the main thread, which is the cost the threshold
+            // exists to avoid, so trying another worker first is strictly better.
+            maxTaskRetries: 2
+        });
+        /* eslint-enable @typescript-eslint/require-await */
+        return xmlPool;
+    }
+    catch {
+        xmlPoolUnavailable = true;
+        return null;
+    }
+}
+/**
+ * `inlineBytes` / `inlineMaxBytes` exist to SIZE the threshold before anyone changes it.
+ *
+ * `XML_OFFTHREAD_MIN_BYTES` gates off-threading per document by SIZE, so many small documents all bypass
+ * the protection while their aggregate is what costs. Measured on the sports feed: 99 % of parses were
+ * inline (22,463 vs 118 off-thread, ~29/s during the schedule sweep) at roughly 8-13 % main-thread duty.
+ *
+ * Do NOT lower the threshold on that number alone. Off-threading pays structured-clone costs BOTH ways
+ * (body out, parsed object graph back) and the pool below is ONE worker, so lowering it can cost more
+ * than it saves for small documents. These counters give the size distribution the decision actually
+ * needs: `inlineBytes / inline` is the mean inline document, and `inlineMaxBytes` says how close the
+ * biggest inline document came to the cut-off.
+ *
+ * Note on the memory side of that trade, measured 2026-08-05: the parsed graph is cloned BACK to the main
+ * thread, so off-threading does not reduce main-thread memory at all — it saves parse CPU and costs a
+ * second copy of the graph plus the clone. `offThreadBytes / offThread` (measured ~0.94 MB) is the number
+ * to weigh against RSS before widening this path.
+ */
+const xmlParseStats = {
+    inline: 0,
+    offThread: 0,
+    fallback: 0,
+    inlineBytes: 0,
+    inlineMaxBytes: 0,
+    offThreadBytes: 0,
+    /**
+     * WALL TIME of inline parses — the measurement the size counters above cannot substitute for.
+     *
+     * Sizes say how much data crossed the main thread; only time says whether that cost anything. Without it
+     * the threshold decision stays a guess in both directions: on 2026-08-10 the sports feed showed
+     * `inlineMaxBytes` 130,676 against a 131,072 cutoff (396 bytes under) while `matches:tournament_schedule`
+     * owned the largest event-loop blocks at 872.9 ms — suggestive, but that stage spans fetch, parse AND map
+     * building, so the parse could equally have been 5 ms of it. `inlineMs` settles which.
+     *
+     * Cheap by construction: one `Date.now()` pair around a call that is already the expensive thing.
+     */
+    inlineMs: 0,
+    inlineMaxMs: 0,
+    /**
+     * Documents HANDED to the pool, counted before the await — the counter whose absence made a stall
+     * unreadable.
+     *
+     * `inline` increments before its parse (arrivals) but `offThread` only after the await resolves
+     * (completions), so a queued or lost document appeared in NO counter. On 2026-08-16 `offThread` sat frozen
+     * for five minutes and "the pool is wedged" and "nothing was submitted" were indistinguishable from the
+     * snapshot — they need opposite fixes. `submitted - offThread - fallback` is the backlog, and `inFlight`
+     * is the same quantity as a live gauge.
+     */
+    submitted: 0,
+    inFlight: 0
+};
+/**
+ * Counters for how XML documents were parsed.
+ *
+ * `fallback` is the one to watch: a non-zero and growing value means large documents are being parsed
+ * on the main thread despite the threshold, so the event-loop protection is not actually in effect.
+ */
+function getXmlParseStats() {
+    // The return type is written out explicitly rather than inferred, so it must be extended whenever
+    // `xmlParseStats` gains a field. The spread already copies every property at runtime, so a missing entry
+    // here does not lose data — it makes the data UNREADABLE to typed callers while looking correct, which is
+    // a worse failure than an error. Adding `inlineMs`/`inlineMaxMs` above compiled cleanly without this.
+    return { ...xmlParseStats };
+}
+function resetXmlParseStatsForTests() {
+    xmlParseStats.inline = 0;
+    xmlParseStats.offThread = 0;
+    xmlParseStats.fallback = 0;
+    xmlParseStats.inlineBytes = 0;
+    xmlParseStats.inlineMaxBytes = 0;
+    xmlParseStats.offThreadBytes = 0;
+}
+/** Shut the XML parse pool down (tests, graceful shutdown). Safe to call when none exists. */
+function closeXmlWorkerPool() {
+    if (!xmlPool)
+        return;
+    try {
+        xmlPool.close();
+    }
+    catch {
+        /* already closing */
+    }
+    xmlPool = null;
+    xmlPoolUnavailable = false;
+}
+/**
+ * Parse an XML document, off the main thread when it is large enough to matter.
+ *
+ * Falls back to inline parsing when the document is small, when no worker pool can be created, or when
+ * the worker fails for any reason — the result must be identical either way, so the only difference a
+ * caller can observe is whether the event loop was blocked.
+ */
+async function parseXmlDocument(body) {
+    const bytes = Buffer.byteLength(body);
+    if (bytes < xmlOffThreadMinBytes) {
+        xmlParseStats.inline++;
+        xmlParseStats.inlineBytes += bytes;
+        if (bytes > xmlParseStats.inlineMaxBytes)
+            xmlParseStats.inlineMaxBytes = bytes;
+        // Timed because this call blocks the event loop for its whole duration — see `inlineMs`.
+        const startedAt = Date.now();
+        const parsed = new fast_xml_parser_1.XMLParser(feedXmlParserOptions()).parse(body);
+        const elapsed = Date.now() - startedAt;
+        xmlParseStats.inlineMs += elapsed;
+        if (elapsed > xmlParseStats.inlineMaxMs)
+            xmlParseStats.inlineMaxMs = elapsed;
+        return parsed;
+    }
+    const pool = await xmlWorkerPool();
+    if (!pool) {
+        xmlParseStats.fallback++;
+        return new fast_xml_parser_1.XMLParser(feedXmlParserOptions()).parse(body);
+    }
+    xmlParseStats.submitted++;
+    xmlParseStats.inFlight++;
+    try {
+        const result = (await pool.work({ body }));
+        if (result && typeof result === 'object' && 'data' in result) {
+            xmlParseStats.offThread++;
+            xmlParseStats.offThreadBytes += bytes;
+            return result.data;
+        }
+        xmlParseStats.fallback++;
+        return new fast_xml_parser_1.XMLParser(feedXmlParserOptions()).parse(body);
+    }
+    catch {
+        // A malformed document also lands here, and re-parsing inline is deliberate: the caller then sees
+        // fast-xml-parser's own error rather than a worker-shaped one. A task TIMEOUT arrives here too, which
+        // is the point of having one: it turns a permanent hang into an inline parse.
+        xmlParseStats.fallback++;
+        return new fast_xml_parser_1.XMLParser(feedXmlParserOptions()).parse(body);
+    }
+    finally {
+        xmlParseStats.inFlight--;
+    }
+}
+class TSRequest {
+    static responseBody(response) {
+        if (typeof response === 'string')
+            return response;
+        if (response != null && typeof response === 'object' && 'data' in response) {
+            const data = response.data;
+            if (data == null)
+                return '';
+            if (typeof data === 'string')
+                return data;
+            return String(data);
+        }
+        return response == null ? '' : String(response);
+    }
+    static isNonXmlBody(body) {
+        const t = body.trimStart();
+        return t.startsWith('<!DOCTYPE') || t.startsWith('<html') || t.startsWith('<HTML');
+    }
+    static debugTrace(url, start, options, response) {
+        const ms = Number(new Date()) - Number(start);
+        const resp = typeof response === 'string' && response.length > 4000
+            ? `${response.slice(0, 4000)}…[truncated ${response.length} chars]`
+            : response;
+        console.log(`TSRequest:[${ms} ms][${url}]`, JSON.stringify({ REQUEST: options, RESPONSE: resp }));
+    }
+    static async form(url, options = {}, debug) {
+        options.headers = {
+            ...{ 'Accept': '*/*', 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' }, ...(options.headers || {})
+        };
+        options.acceptAll = debug;
+        options.bcb = JSON.parse;
+        if (options.body !== null && typeof options.body === 'object' && !Buffer.isBuffer(options.body)) {
+            options.body = (0, querystring_1.stringify)(options.body);
+        }
+        const start = new Date();
+        return new Promise((resolve, reject) => TSRequest.raw(url, options).then(response => {
+            if (debug) {
+                TSRequest.debugTrace(url, start, options, response);
+            }
+            if (response) {
+                resolve(response);
+            }
+            else {
+                resolve(response);
+            }
+        }).catch(error => {
+            error.took = `TSRequest:[${Number(new Date()) - Number(start)} ms][${url}]`;
+            error.options = options;
+            reject(error);
+        }));
+    }
+    static async xml(url, options = {}, debug) {
+        const start = new Date();
+        options.headers = {
+            ...{ 'Accept': 'text/xml', 'Content-Type': 'text/xml; charset=UTF-8' }, ...(options.headers || {})
+        };
+        options.acceptAll = debug;
+        if (options.body !== null && typeof options.body === 'object' && !Buffer.isBuffer(options.body)) {
+            options.body = new fast_xml_parser_1.XMLBuilder({ ignoreAttributes: false, attributeNamePrefix: '', attributesGroupName: '$', textNodeName: '_' }).build(options.body);
+        }
+        if (options.body != null && options.body !== '') {
+            Buffer.byteLength(typeof options.body === 'string' ? options.body : String(options.body));
+        }
+        return new Promise((resolve, reject) => TSRequest.raw(url, options).then((response) => {
+            const body = TSRequest.responseBody(response);
+            if (debug) {
+                TSRequest.debugTrace(url, start, options, body);
+            }
+            if (TSRequest.isNonXmlBody(body)) {
+                reject(TSRequest.error('parse', 404, { body: body.slice(0, 200) }));
+                return;
+            }
+            // Large documents parse in a worker so the event loop is not blocked; small ones stay inline.
+            // Output is identical either way — see parseXmlDocument / XML_OFFTHREAD_MIN_BYTES.
+            parseXmlDocument(body).then(resolve, reject);
+        }).catch(error => {
+            error.took = `TSRequest:[${Number(new Date()) - Number(start)} ms][${url}]`;
+            error.options = options;
+            reject(error);
+        }));
+    }
+    static async json(url, options = {}, debug) {
+        options.headers = {
+            ...{ 'Accept': 'application/json', 'Content-Type': 'application/json; charset=UTF-8' }, ...(options.headers || {})
+        };
+        options.acceptAll = debug;
+        options.bcb = (response) => {
+            try {
+                return JSON.parse(response);
+            }
+            catch (e) {
+                console.error(e);
+                return response;
+            }
+        };
+        if (options.body !== null && typeof options.body === 'object' && !Buffer.isBuffer(options.body)) {
+            options.body = JSON.stringify(options.body);
+        }
+        const start = new Date();
+        return new Promise((resolve, reject) => TSRequest.raw(url, options).then(response => {
+            if (debug) {
+                TSRequest.debugTrace(url, start, options, response);
+            }
+            if (response && response.data) {
+                resolve(response.data);
+            }
+            else {
+                resolve(response);
+            }
+        }).catch(error => {
+            error.took = `TSRequest:[${Number(new Date()) - Number(start)} ms][${url}]`;
+            error.options = options;
+            reject(error);
+        }));
+    }
+    static async raw(url, options = {}) {
+        const signal = options.signal;
+        if (signal?.aborted) {
+            return Promise.reject((0, abort_1.abortError)());
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let req;
+            let onAbort;
+            const cleanupAbort = () => {
+                if (signal && onAbort) {
+                    signal.removeEventListener('abort', onAbort);
+                }
+            };
+            const finish = (action, value, err) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanupAbort();
+                if (action === 'resolve') {
+                    resolve(value);
+                }
+                else {
+                    reject(err);
+                }
+            };
+            if (signal) {
+                onAbort = () => {
+                    const abortErr = (0, abort_1.abortError)();
+                    try {
+                        req?.destroy(abortErr);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    finish('reject', undefined, abortErr);
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+            const params = TSRequest.url(url);
+            const optsForRequest = { ...options };
+            delete optsForRequest.signal;
+            Object.assign(params, optsForRequest);
+            if (!params.method) {
+                params.method = 'get';
+            }
+            if (params.search) {
+                params.path = params.path + params.search;
+            }
+            if (params.qs) {
+                params.path = params.path + (params.path.indexOf('?') > -1 ? '&' : '?') + (0, querystring_1.stringify)(params.qs);
+            }
+            try {
+                req = (params.protocol === 'https:' ? https : http).request(params, res => {
+                    const statusCode = res.statusCode ?? 0;
+                    if (!params.acceptAll && (statusCode < 200 || statusCode >= 300)) {
+                        res.resume();
+                        finish('reject', undefined, TSRequest.error('response', statusCode, { statusMessage: res.statusMessage, headers: res.headers }));
+                        return;
+                    }
+                    const chunks = [];
+                    res.on('data', chunk => chunks.push(chunk));
+                    res.on('end', () => {
+                        try {
+                            const buffer = Buffer.concat(chunks).toString();
+                            const body = params.bcb
+                                ? { kind: 'success', status: statusCode, message: res.statusMessage, headers: res.headers, data: params.bcb(buffer) }
+                                : buffer;
+                            finish('resolve', body);
+                        }
+                        catch (e) {
+                            const msg = e instanceof Error ? e.message : String(e);
+                            finish('reject', undefined, TSRequest.error('parse', !params.acceptAll ? 109 : statusCode, { statusMessage: res.statusMessage, headers: res.headers, error: msg, body: chunks }));
+                        }
+                    });
+                });
+                req.on('error', e => {
+                    finish('reject', undefined, TSRequest.error('error', 545, e.message));
+                });
+                req.on('timeout', () => {
+                    const error = TSRequest.error('timeout', 563, 'Request destroyed');
+                    req?.destroy(error);
+                    finish('reject', undefined, error);
+                });
+                if (options.body) {
+                    req.write(options.body);
+                }
+                req.end();
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                finish('reject', undefined, err);
+            }
+        });
+    }
+    static error(kind, status, message) {
+        return new Error(JSON.stringify({ kind: kind, status: status, message: message }));
+    }
+    static url(url) {
+        const m = /^(https?:)\/\/(([^:/?#]*)(?::([0-9]+))?)([/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/.exec(url);
+        return m ? {
+            href: url, protocol: m[1], host: m[2], hostname: m[3], port: m[4], path: m[5], pathname: m[5], search: m[6], hash: m[7]
+        } : {};
+    }
+}
+exports.TSRequest = TSRequest;
+function request(url, { body = undefined, qs = undefined, debug = undefined, ...options } = {}, kind = 'json') {
+    if (!options) {
+        options = {};
+    }
+    if (body) {
+        options.body = body;
+    }
+    else if (qs) {
+        options.qs = qs;
+        options.method = 'get';
+    }
+    options.rejectUnauthorized = false;
+    options.timeout = options.timeout || 18000;
+    return new Promise(resolve => TSRequest[kind](url, options, debug).catch((error) => {
+        if (debug)
+            console.error(error);
+        resolve({});
+    }).then(data => resolve(data)));
+}