@a11ign/screenreader-fleet 0.0.0-reserved.0 → 0.1.0

package/dist/worker-http.mjs

@@ -0,0 +1,277 @@
+// @ts-check
+/**
+ * HTTP to a capture worker, on a connection that may stay silent for ten minutes.
+ *
+ * ## Why this is not `fetch`
+ *
+ * Node's global `fetch` is undici, and undici caps the wait for RESPONSE HEADERS at 300 s
+ * (`headersTimeout`). `AbortSignal.timeout()` does not govern it — it is a separate mechanism, settable
+ * only through a dispatcher. Measured on Node v24.7.0 against a server that withheld headers for 310 s:
+ *
+ *     global fetch  + AbortSignal.timeout(560s) : THREW — TypeError: fetch failed :: UND_ERR_HEADERS_TIMEOUT
+ *     node:http request                         : SURVIVED — got 200
+ *
+ * That cap lands squarely inside this project's own budget ladder. `capture-pure.mjs` sets a 420 s sweep
+ * budget inside a 520 s hard timeout, deliberately raised so that "a real page was sampled not validated",
+ * and the three clients then declared 560 s, 560 s and 320 s. Every one of those numbers is above 300 s, so
+ * the effective ceiling was undici's — not any constant in this repo.
+ *
+ * The failure is silent and it destroys evidence. The worker writes its status and body together at the END
+ * of a capture (`send(res, 200, {...})`), so headers arrive last; a capture that takes 301 s therefore has
+ * its socket torn down by the CLIENT at the moment it finishes, and the worker writes a completed capture
+ * into a dead socket. The host sees `fetch failed`, classifies it transient, and retries — paying another
+ * full capture to reach the same cliff. Three such pages in a row on one worker trips `shouldEvictWorker`
+ * and removes a machine that was never faulty.
+ *
+ * `cli.ts` had the diagnosis exactly right in a comment — it names `UND_ERR_HEADERS_TIMEOUT` and the ~300 s
+ * cap — and then raised an `AbortSignal`, which governs a different mechanism. This repo's own "a comment
+ * that names an ambiguity, above code that resolves it by assumption", one step worse: the comment named
+ * the mechanism and the code still addressed another one.
+ *
+ * ## Why not an undici dispatcher
+ *
+ * `undici` is not a dependency here, and installing it would not help by itself: the standalone package
+ * keeps its own global dispatcher, so `setGlobalDispatcher` does not reach Node's built-in `fetch`. Using
+ * it would mean importing undici's `fetch` too. `node:http` is in core, has no client-side headers cap at
+ * all, and gives us one explicit deadline over the whole exchange instead of three interacting ones.
+ *
+ * ## Errors carry a CODE
+ *
+ * `node:http` reports `error.code` (`ECONNREFUSED`, `EHOSTUNREACH`, `ECONNRESET`) where `fetch` collapsed
+ * everything into `TypeError: fetch failed`. That is strictly better — `capture-faults.mjs` records what
+ * matching on prose costs — but it is a behaviour change the retry logic has to know about, so
+ * `isTransient` now keys on those codes. `EHOSTUNREACH` matters most: it is how a bare-metal worker's NIC
+ * waking from selective suspend presents, and under `fetch` it was transient only by accident, because the
+ * wrapper said "fetch failed".
+ */
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+/**
+ * How long a CLIENT should wait for a capture. One definition, because five had drifted.
+ *
+ * It must exceed the worker's own hard timeout (`CAPTURE_HARD_TIMEOUT_DEFAULT_MS`, 520 s) or the client
+ * gives up first, and a capture the worker would have completed is reported as a client failure. Five
+ * clients sat at 300 s -- `compare-workers`, `bench-capture`, `evidence-check`, `repeat-capture` and
+ * `capture-real-pages` -- against that 520 s. On the generated corpus nothing noticed, because a 1,338-byte
+ * page finishes in seconds. On REAL pages it silently dropped whatever used its budget, biasing the
+ * real-page corpus toward small simple pages: precisely the axis that corpus exists to add.
+ *
+ * 560,000 -> 620,000 on architecture-audit.md §14.5: `runCapture` (server.mjs) spends up to
+ * `DESKTOP_PREPARE_TIMEOUT_MS` (60 s) clearing the desktop BEFORE the hard-timeout-wrapped capture attempt
+ * even starts, sequentially rather than overlapping it -- so the true worst case a worker can legitimately
+ * take is 60 s + 520 s = 580 s, not 520 s alone. The old 560 s ceiling sat BELOW that, so a real page that
+ * used the full prepare budget and the full capture budget was killed by the CLIENT first and reported as
+ * a client failure for work the worker would have finished -- the exact shape this constant already exists
+ * to prevent, one rung further out. 620,000 keeps the same 40 s margin above the new true worst case that
+ * the original 560,000 kept above 520,000. `budget-ladder.test.ts` asserts the full sequence, not only the
+ * capture attempt inside it.
+ *
+ * Deliberately NOT imported from `@a11ign/screenreader-worker`: this package runs on macOS and Linux and must
+ * not depend on a win32-only one. `budget-ladder.test.ts` enforces the relationship instead, over every
+ * client it DISCOVERS rather than a list -- which is how the 300 s clients stayed invisible while a guard
+ * for exactly this existed and read one hardcoded path.
+ *
+ * `DATASET_CAPTURE_TIMEOUT_MS` still overrides it in the dataset runner, which is the only client that
+ * wants a per-run ceiling.
+ */
+export const CAPTURE_CLIENT_TIMEOUT_MS = 620_000;
+/**
+ * How long a capture's silent connection may idle before the OS proves it is still there.
+ *
+ * 15 s, and RAISING IT TO 60 s WAS TRIED AND REVERTED — by this file's own test, which refuses a delay
+ * above ~30 s because common NAT idle timeouts start there.
+ *
+ * The reasoning for raising it was that the async path removed the long-lived connection, so nothing needs
+ * an aggressive value. That is true of the async path and FALSE of the `A11Y_SYNC_CAPTURE` escape hatch,
+ * which still holds one socket silent for a whole capture. At 60 s the first probe would fire after the
+ * reap, so the hatch would be unprotected while the constant looked deliberate — a guard weakened for a
+ * reason that did not cover the case it exists for.
+ *
+ * It stays aggressive until item D explains why THIS path reaps in seconds when the literature says
+ * minutes. An unexplained number is not a solved problem.
+ *
+ * EXPORTED so its test can key on the exact value. Node's own HTTP SERVER calls `setKeepAlive(true, 5000)`
+ * on every socket it accepts, so a test that merely looked for "keepalive with a plausible delay" matched
+ * the server's call and passed with this hook DELETED — found by mutation, not by reading.
+ */
+export const KEEPALIVE_DELAY_MS = 15_000;
+/**
+ * A worker address, validated at the BOUNDARY where it enters the program.
+ *
+ * `requestJson` already calls `new URL(url)`, which throws `ERR_INVALID_URL` on a malformed address — so an
+ * empty host dies in under a second, in principle. In practice it did not, and the way it did not is the
+ * reason this function exists.
+ *
+ * `--worker=http://:8765` reached `capture-real-pages.mjs` because nothing there did more than check the
+ * value was truthy, and `http://:8765` is truthy. The readiness loop then caught the resulting
+ * `ERR_INVALID_URL` in a bare `catch` whose only content was the comment "mid-boot or mid-restart; keep
+ * waiting", and so classified a permanent
+ * programmer error as a transient network condition: 60 attempts, 5 s apart, per page — then recorded
+ * "worker never became ready" as a failure of the PAGE. Four shards spent 29 minutes that way while every
+ * worker sat idle, and the run blamed the corpus.
+ *
+ * So the fix is two-part and both halves are needed: refuse the value here, and stop the readiness loop
+ * swallowing what it cannot recover from. Validating without fixing the catch leaves the next unrecoverable
+ * error to be absorbed the same way.
+ *
+ * Node's URL parser does the work. There is no regex here on purpose — a hand-rolled one would accept
+ * `http://:8765` again, since the only thing wrong with it is an empty host. Note `http:/x` and
+ * `http:///path` DO parse, to host `x` and host `path`; that is the parser's business and not something to
+ * second-guess here.
+ *
+ * @param {string | null | undefined} value the raw `--worker=` or `A11Y_WORKER` value
+ * @param {{ source?: string }} [options] what to name in the error, e.g. "--worker"
+ * @returns {string} the address, trailing slash removed
+ */
+export function assertWorkerUrl(value, { source = "--worker" } = {}) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${source} is required and was empty. Give a worker address, e.g. ${source}=http://192.0.2.10:8765`);
+    }
+    const raw = value.trim().replace(/\/$/, "");
+    let target;
+    try {
+        target = new URL(raw);
+    }
+    catch (cause) {
+        // A missing HOST lands here rather than in a hostname check below, and there is no such check on
+        // purpose: verified against Node's parser, no `http:`/`https:` URL can parse with an empty hostname —
+        // `http://`, `http://:8765` and `http://:/x` all throw. A `!target.hostname` branch would therefore be
+        // unreachable, which is this repo's own most-repeated defect, so the message that belongs to that case
+        // is folded in here where it can actually be read.
+        throw new Error(`${source}=${raw} is not a URL. Expected something like http://192.0.2.10:8765\n`
+            + "If the host is missing, that is what a shell variable expanding to nothing looks like: a bash "
+            + "array does not survive `nohup bash -c`, and zsh does not word-split a scalar. Both produce "
+            + "exactly this.", { cause });
+    }
+    if (target.protocol !== "http:" && target.protocol !== "https:") {
+        throw new Error(`${source}=${raw} must be http: or https:, not ${target.protocol}`);
+    }
+    return raw;
+}
+/**
+ * One request, with a single deadline covering connect, headers and body.
+ *
+ * @param {string} url
+ * @param {{ method?: string, body?: unknown, timeoutMs?: number }} [options]
+ * @returns {Promise<{ status: number, ok: boolean, text: string, json: any }>}
+ *   `json: any`, not `unknown`. This is a JSON body off the wire, and every caller reads named fields
+ *   from it -- `body.error`, `body.fault`, `health.busy`, `body.transcript`. `unknown` makes each of
+ *   those a cast, and a cast written to satisfy a checker asserts a shape nobody verified, which is
+ *   strictly worse than saying the value is untyped. The SHAPE that matters is checked where it is
+ *   defined: `capture-core`'s `Capture` typedef, and the worker's own `/health` contract.
+ */
+export function requestJson(url, { method = "GET", body, timeoutMs = 30_000 } = {}) {
+    const target = new URL(url);
+    const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const payload = body === undefined ? null : JSON.stringify(body);
+    return new Promise((resolve, reject) => {
+        const req = send(target, { method, headers: requestHeaders(payload) }, (res) => {
+            collect(res).then((text) => {
+                clearTimeout(deadline);
+                // `?? 0` because node types `statusCode` optional -- it is set on every client response, and a 0
+                // would fall out of the 2xx range exactly as an absent one should, so the fallback cannot change
+                // an answer. Named once rather than read three times.
+                const status = res.statusCode ?? 0;
+                resolve({ status, ok: status >= 200 && status < 300, text, json: parse(text) });
+            }, failWith);
+        });
+        // Our own deadline, because node:http has no equivalent of a total-request timeout: its `timeout`
+        // option measures socket INACTIVITY, which a worker holding a connection open while NVDA reads a page
+        // never trips. The message says "timed out" so the prose fallback in isTransient still classifies it,
+        // and the code says so too for anything that prefers codes.
+        const deadline = setTimeout(() => {
+            // Typed as an ErrnoException so the `code` this deliberately attaches is describable. Recovery in
+            // this repo is keyed on CODES and never on message text (`capture-faults.mjs`), so the field is
+            // load-bearing rather than decorative.
+            const error = /** @type {NodeJS.ErrnoException} */ (new Error(`Request to ${url} timed out after ${timeoutMs} ms`));
+            error.code = "ETIMEDOUT";
+            req.destroy(error);
+        }, timeoutMs);
+        /** @param {unknown} error */
+        function failWith(error) {
+            clearTimeout(deadline);
+            reject(error);
+        }
+        // KEEPALIVE, KEPT ON PRECAUTIONARY GROUNDS ONLY. ITS DIAGNOSIS WAS WRONG, AND THE REASON IS TOPOLOGY.
+        //
+        // The story attached to this was: a capture holds a connection SILENT for minutes, so NAT and Wi-Fi
+        // power-save reap it as idle. It was argued from *High Performance Browser Networking* -- "Most mobile
+        // carriers set a 5-30 minute NAT connection timeout" -- and that passage is about MOBILE CARRIERS AND
+        // THE PUBLIC INTERNET.
+        //
+        // THIS IS A LAN. The control plane and every worker sit on the same /24; the route between them is
+        // `link#14`, direct on the link layer with no gateway hop. NAT happens at the router on the
+        // way OUT. There is no translation table between these hosts, so there is nothing here that a NAT
+        // timeout could expire. The theory was inapplicable from the first line, and the mismatch went
+        // unnoticed because the quotation fitted the SYMPTOM.
+        //
+        // The measurements agree, which is how it was caught rather than believed. Keepalive explicitly OFF,
+        // ~26 s silent captures:
+        //
+        //     8 sequential on one box        0 lost
+        //     15 across five boxes at once   0 lost    <- the exact condition the 9/40 was measured under
+        //
+        // 0 of 23. At the old 22% rate P(0 in 23) = 0.78^23 = 0.4%, so the rate really did change -- and these
+        // trials ran WITHOUT the keepalive, so it is not shown to be why. Losses went 9/40 -> 0 when it landed
+        // and nobody tested removing it: "a green result vouches for the mechanism", committed inside the work
+        // that kept finding that trap elsewhere.
+        //
+        // So: the losses were REAL and their cause is UNKNOWN. NAT is excluded by topology; the worker's own
+        // `keepAliveTimeout` and `requestTimeout` were excluded by measurement; the boxes' NIC power settings
+        // were already correct. What is left is the Wi-Fi association itself or something transient, and this
+        // comment will not guess again.
+        //
+        // Item A is unaffected and that is the useful part: the async path holds no long connection at all, so
+        // it is immune whatever the mechanism was. A STRUCTURAL FIX DOES NOT DEPEND ON THE DIAGNOSIS BEING
+        // RIGHT, which is the strongest argument there is for preferring one.
+        req.on("socket", (socket) => {
+            socket.setKeepAlive(true, KEEPALIVE_DELAY_MS);
+            // Nagle would batch the request itself; a capture POST is one small write followed by a wait, so
+            // there is nothing to batch and delaying it only adds latency to the request that starts the work.
+            socket.setNoDelay(true);
+        });
+        req.on("error", failWith);
+        if (payload !== null)
+            req.write(payload);
+        req.end();
+    });
+}
+/** @param {string | null} payload */
+function requestHeaders(payload) {
+    if (payload === null)
+        return { accept: "application/json" };
+    return {
+        accept: "application/json",
+        "content-type": "application/json",
+        // Explicit, so the worker never has to read a chunked body. Byte length, not character count:
+        // a non-ASCII task string would otherwise under-declare and the worker would wait for bytes
+        // that never arrive.
+        "content-length": Buffer.byteLength(payload),
+    };
+}
+/**
+ * @param {import("node:http").IncomingMessage} res
+ * @returns {Promise<string>}
+ */
+function collect(res) {
+    return new Promise((resolve, reject) => {
+        let text = "";
+        res.setEncoding("utf8");
+        res.on("data", (/** @type {string} */ chunk) => { text += chunk; });
+        res.on("end", () => resolve(text));
+        res.on("error", reject);
+    });
+}
+/**
+ * Parsed JSON, or undefined — a worker error page is not a parse failure worth throwing over.
+ * @param {string} text
+ */
+function parse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=worker-http.mjs.map

package/dist/worker-http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-http.mjs","sourceRoot":"","sources":["../src/worker-http.mjs"],"names":[],"mappings":"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"}

package/dist/worker-stats.d.mts

@@ -0,0 +1,66 @@
+/** Linear-interpolated quantile. Fine for the sample sizes here and has no dependencies. */
+/** @param {number[]} values @param {number} q @returns {number|null} */
+export function quantile(values: number[], q: number): number | null;
+/**
+ * The shape of one worker's samples.
+ *
+ * `iqr` is the spread that matters: half the runs fall inside it, so two workers whose IQRs overlap are
+ * not distinguishable by these samples however different their medians look.
+ */
+/**
+ * @param {number[]} values
+ * @returns {Summary|null}
+ */
+export function describe(values: number[]): Summary | null;
+/**
+ * Compare workers and say, conservatively, whether a difference is supported.
+ *
+ * The bar is deliberately crude and deliberately strict: medians must differ by more than the wider
+ * worker's IQR, and the two IQRs must not overlap. That is a weaker claim than a significance test and a
+ * much stronger one than "the mean was higher", which is what produced every wrong conclusion this
+ * module was written after. When the samples do not clear it, the verdict is "not distinguishable" —
+ * which is a real answer, not a failure to find one.
+ *
+ * @param {Record<string, number[]>} samplesByWorker
+ * @returns {{ stats: Record<string, Summary>, slowest: string|null, fastest: string|null,
+ *             distinguishable: boolean, verdict: string }}
+ */
+export function compareWorkers(samplesByWorker: Record<string, number[]>): {
+    stats: Record<string, Summary>;
+    slowest: string | null;
+    fastest: string | null;
+    distinguishable: boolean;
+    verdict: string;
+};
+/**
+ * Recovery rate per worker — the reliability statistic, as opposed to the speed one.
+ *
+ * Counted from the worker's own `vitals.recoveries` across the run, because a guest whose screen reader
+ * keeps dying still returns evidence and still records zero failures. Speed and reliability are separate
+ * questions and a fast worker can be the unreliable one.
+ *
+ * @param {Record<string, {recoveries: number, captures: number}>} deltas
+ * @returns {Record<string, number | null>} null where the worker captured nothing — "no idea", which
+ *   must not be confused with a rate of zero ("perfectly reliable").
+ */
+export function recoveryRates(deltas: Record<string, {
+    recoveries: number;
+    captures: number;
+}>): Record<string, number | null>;
+/**
+ * One worker's samples, summarised.
+ *
+ * Named as a typedef rather than repeated inline because four functions pass it around, and this module's
+ * whole purpose is refusing to claim a difference the samples do not support — so `q1`, `q3` and `iqr`
+ * travelling together, as one thing with one name, is the point rather than a formality.
+ */
+export type Summary = {
+    n: number;
+    median: number;
+    q1: number;
+    q3: number;
+    iqr: number;
+    min: number;
+    max: number;
+};
+//# sourceMappingURL=worker-stats.d.mts.map

package/dist/worker-stats.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-stats.d.mts","sourceRoot":"","sources":["../src/worker-stats.mjs"],"names":[],"mappings":"AAuCA,4FAA4F;AAC5F,wEAAwE;AACxE,iCADY,MAAM,EAAE,KAAiB,MAAM,GAAc,MAAM,GAAC,IAAI,CAOnE;AAED;;;;;GAKG;AACH;;;GAGG;AACH,iCAHW,MAAM,EAAE,GACN,OAAO,GAAC,IAAI,CAexB;AAOD;;;;;;;;;;;;GAYG;AACH,gDAJW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACtB;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;IAC3E,eAAe,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAqCzD;AAED;;;;;;;;;;GAUG;AACH,sCAJW,MAAM,CAAC,MAAM,EAAE;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,GACpD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAUzC;;;;;;;;sBAtHY;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAC/D,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC"}

package/dist/worker-stats.mjs

@@ -0,0 +1,143 @@
+// @ts-check
+/**
+ * Robust statistics for comparing workers, and an explicit refusal to call a difference real when the
+ * samples do not support it.
+ *
+ * This module exists because of a specific, repeated mistake: concluding from one measurement. Over one
+ * session a 2x difference between two guests was attributed, in turn, to the display being blanked, to
+ * in-memory accumulation, to background CPU, to Edge's launch, to the Edge profile, to the sweep, and to
+ * Edge's startup boost. Every one of those was a single measurement, and every one was wrong.
+ *
+ * Two things caused that, and both are fixed here rather than in a comment.
+ *
+ * **Means lied.** One 63 s outlier in an eight-run sample moved the mean by 5 s and made a healthy
+ * worker look broken. Capture time has a long right tail by nature — a mute screen reader costs ~86 s
+ * against a normal ~12 s — so the mean measures how often the tail was hit, not what a capture costs.
+ * The median and the interquartile range do not move when one run goes bad.
+ *
+ * **Sequential sampling confounded.** Measuring worker A for five minutes and then worker B for five
+ * minutes attributes any drift in the host during those ten minutes to the difference between the
+ * workers. Interleaving round-robin makes drift common to all of them.
+ */
+/**
+ * One worker's samples, summarised.
+ *
+ * Named as a typedef rather than repeated inline because four functions pass it around, and this module's
+ * whole purpose is refusing to claim a difference the samples do not support — so `q1`, `q3` and `iqr`
+ * travelling together, as one thing with one name, is the point rather than a formality.
+ *
+ * @typedef {{n: number, median: number, q1: number, q3: number, iqr: number,
+ *            min: number, max: number}} Summary
+ */
+/** Below this many rounds, report the numbers but never claim a difference. */
+const MIN_ROUNDS_FOR_A_VERDICT = 5;
+/** @param {number[]} values @returns {number[]} */
+const sorted = (values) => [...values].sort((a, b) => a - b);
+/** Linear-interpolated quantile. Fine for the sample sizes here and has no dependencies. */
+/** @param {number[]} values @param {number} q @returns {number|null} */
+export function quantile(values, q) {
+    if (!values.length)
+        return null;
+    const s = sorted(values);
+    const position = (s.length - 1) * q;
+    const low = Math.floor(position), high = Math.ceil(position);
+    return low === high ? s[low] : s[low] + (s[high] - s[low]) * (position - low);
+}
+/**
+ * The shape of one worker's samples.
+ *
+ * `iqr` is the spread that matters: half the runs fall inside it, so two workers whose IQRs overlap are
+ * not distinguishable by these samples however different their medians look.
+ */
+/**
+ * @param {number[]} values
+ * @returns {Summary|null}
+ */
+export function describe(values) {
+    if (!values.length)
+        return null;
+    // Non-null by construction: `quantile` returns null only for an empty list, and the guard above has
+    // already excluded that. Written as a local rather than an assertion so the reason is stated once.
+    const q1 = /** @type {number} */ (quantile(values, 0.25));
+    const q3 = /** @type {number} */ (quantile(values, 0.75));
+    return {
+        n: values.length,
+        median: /** @type {number} */ (quantile(values, 0.5)),
+        q1, q3, iqr: q3 - q1,
+        min: Math.min(...values),
+        max: Math.max(...values),
+    };
+}
+/** Do two interquartile ranges overlap at all? @param {Summary} a @param {Summary} b */
+function overlaps(a, b) {
+    return a.q1 <= b.q3 && b.q1 <= a.q3;
+}
+/**
+ * Compare workers and say, conservatively, whether a difference is supported.
+ *
+ * The bar is deliberately crude and deliberately strict: medians must differ by more than the wider
+ * worker's IQR, and the two IQRs must not overlap. That is a weaker claim than a significance test and a
+ * much stronger one than "the mean was higher", which is what produced every wrong conclusion this
+ * module was written after. When the samples do not clear it, the verdict is "not distinguishable" —
+ * which is a real answer, not a failure to find one.
+ *
+ * @param {Record<string, number[]>} samplesByWorker
+ * @returns {{ stats: Record<string, Summary>, slowest: string|null, fastest: string|null,
+ *             distinguishable: boolean, verdict: string }}
+ */
+export function compareWorkers(samplesByWorker) {
+    /** @type {Record<string, Summary>} */
+    const stats = {};
+    for (const [worker, values] of Object.entries(samplesByWorker)) {
+        const description = describe(values);
+        if (description)
+            stats[worker] = description;
+    }
+    const names = Object.keys(stats);
+    if (names.length < 2) {
+        return { stats, slowest: null, fastest: null, distinguishable: false, verdict: "need at least two workers with samples" };
+    }
+    const rounds = Math.min(...names.map((n) => stats[n].n));
+    const byMedian = [...names].sort((a, b) => stats[a].median - stats[b].median);
+    const fastest = byMedian[0], slowest = byMedian[byMedian.length - 1];
+    const gap = stats[slowest].median - stats[fastest].median;
+    const widest = Math.max(stats[fastest].iqr, stats[slowest].iqr);
+    if (rounds < MIN_ROUNDS_FOR_A_VERDICT) {
+        return {
+            stats, slowest, fastest, distinguishable: false,
+            verdict: `only ${rounds} round(s) — too few to claim anything. Run at least ${MIN_ROUNDS_FOR_A_VERDICT}.`,
+        };
+    }
+    if (gap <= widest || overlaps(stats[fastest], stats[slowest])) {
+        return {
+            stats, slowest, fastest, distinguishable: false,
+            verdict: `NOT DISTINGUISHABLE: medians differ by ${gap.toFixed(1)} but the spread is ${widest.toFixed(1)} ` +
+                "and the interquartile ranges overlap. These samples do not support a difference between the workers.",
+        };
+    }
+    return {
+        stats, slowest, fastest, distinguishable: true,
+        verdict: `${slowest} is slower than ${fastest} by ${gap.toFixed(1)} (medians), ` +
+            `with non-overlapping interquartile ranges over ${rounds} interleaved rounds.`,
+    };
+}
+/**
+ * Recovery rate per worker — the reliability statistic, as opposed to the speed one.
+ *
+ * Counted from the worker's own `vitals.recoveries` across the run, because a guest whose screen reader
+ * keeps dying still returns evidence and still records zero failures. Speed and reliability are separate
+ * questions and a fast worker can be the unreliable one.
+ *
+ * @param {Record<string, {recoveries: number, captures: number}>} deltas
+ * @returns {Record<string, number | null>} null where the worker captured nothing — "no idea", which
+ *   must not be confused with a rate of zero ("perfectly reliable").
+ */
+export function recoveryRates(deltas) {
+    /** @type {Record<string, number | null>} */
+    const rates = {};
+    for (const [worker, d] of Object.entries(deltas)) {
+        rates[worker] = d.captures > 0 ? d.recoveries / d.captures : null;
+    }
+    return rates;
+}
+//# sourceMappingURL=worker-stats.mjs.map

package/dist/worker-stats.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-stats.mjs","sourceRoot":"","sources":["../src/worker-stats.mjs"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,99 @@
 {
   "name": "@a11ign/screenreader-fleet",
-  "version": "0.0.0-reserved.0",
+  "version": "0.1.0",
+  "description": "Host-side lifecycle, health and capacity for a fleet of Windows NVDA capture workers: lease one, judge whether it is degrading, and know how many the host can afford.",
   "license": "AGPL-3.0-or-later",
-  "description": "Reserved name. Real releases are published by a11ign/screenreader-fleet's release workflow.",
-  "repository": { "type": "git", "url": "git+https://github.com/a11ign/screenreader-fleet.git" }
-}
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./health": {
+      "default": "./dist/worker-health.mjs"
+    },
+    "./capacity": {
+      "default": "./dist/host-capacity.mjs"
+    },
+    "./probe-outcome": {
+      "types": "./dist/probe-outcome.d.mts",
+      "default": "./dist/probe-outcome.mjs"
+    },
+    "./worker-http": {
+      "types": "./dist/worker-http.d.mts",
+      "default": "./dist/worker-http.mjs"
+    },
+    "./cli-flags": {
+      "default": "./dist/cli-flags.mjs"
+    },
+    "./transient-fault": {
+      "types": "./dist/transient-fault.d.mts",
+      "default": "./dist/transient-fault.mjs"
+    },
+    "./capture-client": {
+      "types": "./dist/capture-client.d.mts",
+      "default": "./dist/capture-client.mjs"
+    },
+    "./host-address": {
+      "types": "./dist/host-address.d.mts",
+      "default": "./dist/host-address.mjs"
+    },
+    "./fleet-env": {
+      "types": "./dist/fleet-env.d.mts",
+      "default": "./dist/fleet-env.mjs"
+    },
+    "./fleet-consistency": {
+      "types": "./dist/fleet-consistency.d.mts",
+      "default": "./dist/fleet-consistency.mjs"
+    },
+    "./worker-code-check": {
+      "types": "./dist/worker-code-check.d.mts",
+      "default": "./dist/worker-code-check.mjs"
+    }
+  },
+  "bin": {
+    "a11ign-doctor": "./dist/doctor.mjs",
+    "a11ign-worker-code": "./dist/check-worker-code.mjs",
+    "a11ign-worker-compare": "./dist/compare-workers.mjs",
+    "a11ign-worker-ctl": "./src/local-worker/worker-ctl.sh",
+    "a11ign-worker-deploy": "./dist/deploy-worker.mjs"
+  },
+  "files": [
+    "dist",
+    "src/local-worker",
+    "src/provisioning",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@a11ign/judge": "0.1.0",
+    "@a11ign/screenreader-worker": "0.1.0"
+  },
+  "devDependencies": {
+    "@a11ign/evidence": "0.1.0",
+    "yaml": "^2.9.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a11ign/screenreader-fleet.git",
+    "directory": "packages/worker-fleet"
+  },
+  "homepage": "https://github.com/a11ign/screenreader-fleet",
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "nvda",
+    "screen-reader",
+    "windows",
+    "utm",
+    "vm"
+  ],
+  "scripts": {}
+}