@a11ign/screenreader-fleet 0.1.0 → 0.3.0

package/dist/control-plane-isolation.d.mts

@@ -42,4 +42,3 @@ export function controlPlaneIsolation({ hasNodeModules, hasFleetKey, packages, i
     violated: boolean;
     why: string;
 };
-//# sourceMappingURL=control-plane-isolation.d.mts.map

package/dist/deploy-worker.d.mts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=deploy-worker.d.mts.map

package/dist/deploy-worker.mjs

@@ -1,295 +1,165 @@
 #!/usr/bin/env node
-// @ts-check
-// Deploy the worker's code to the guests, in one command, and prove it landed.
-//
-//   node scripts/deploy-worker.mjs              # every local worker VM, one at a time
-//   node scripts/deploy-worker.mjs --vm=a11y-worker-2
-//
-// Why this exists: deploying was a documented twelve-step manual dance — push four files with
-// `utmctl file push`, stop the VM, start it, then run `worker:code` and hope. Two things about that
-// were unacceptable for something we rely on:
-//
-//  - **It is easy to get wrong, and I got it wrong.** Pushing three of the four files leaves a guest
-//    running a mix; the symptom is a `worker:code` mismatch with no clue which file is stale.
-//  - **`utmctl exec` cannot be trusted to restart the worker**, so the reboot is mandatory and easy to
-//    skip. Skipping it makes the guest serve the previous code while reporting success — which cost two
-//    workers an hour of running stale code once already.
-//
-// So: one command, every hashed file, a real reboot, and a hash check over HTTP afterwards. The hash
-// check is the whole point — it shares no failure mode with the push, which is why `/health.code`
-// exists rather than reading the guest's files back through the same broken channel.
-//
-// Deploys the WORKING TREE, deliberately: that is what you are testing. Roll back by checking out the
-// ref you want and running this again — git is the source of truth for "the previous version", so there
-// is no bespoke backup to go stale.
 import { pathToFileURL } from "node:url";
 import { execFile, execFileSync } from "node:child_process";
-import { sandboxGitEnv } from "./git-safe-env.mjs";
 import { createReadStream, realpathSync } from "node:fs";
 import { promisify } from "node:util";
-import { resolve } from "node:path";
-// By SUBPATH, never the package ROOT: the index re-exports `capture-core.mjs`, which imports guidepup and
-// throws `No available supported screen readers` at import on any host without one. This file only
-// runs on a Mac, where VoiceOver makes that throw invisible — which is exactly why it went unnoticed.
-// `no-win32-imports.test.ts` found it.
+import { resolve as external_node_path_resolve } from "node:path";
 import { WORKER_FILES } from "@a11ign/screenreader-worker/worker-files";
-import { workerSourceDir, codeVersion } from "@a11ign/screenreader-worker/code-version";
-// The WORKING-TREE value, imported rather than regex-scraped — architecture-audit.md §5, item 3.
-// `protocol-version.mjs` is dependency-free for exactly this: safe to import from a portable tree, unlike
-// the package ROOT or `capture-core.mjs` itself, which reach guidepup. The git-HEAD comparison below still
-// has to scrape TEXT, because `git show` returns a historical file's bytes, not something importable.
-import { CAPTURE_PROTOCOL_VERSION as PROTOCOL_IN_TREE } from "@a11ign/screenreader-worker/protocol-version";
-import { fleetScriptPaths } from "./fleet-scripts.mjs";
+import { codeVersion, workerSourceDir } from "@a11ign/screenreader-worker/code-version";
+import { CAPTURE_PROTOCOL_VERSION } from "@a11ign/screenreader-worker/protocol-version";
+import { requestJson as worker_http_requestJson } from "./worker-http.mjs";
+import { fleetScriptPaths } from "./src_fleet-scripts_mjs.mjs";
 import { refuseUnknownFlags, flagValue } from "./cli-flags.mjs";
-import { warnUtmDeprecated } from "./utm-deprecated.mjs";
-import { requestJson } from "./worker-http.mjs";
-import { RECAPTURE_COST } from "./protocol-guard.mjs";
-/**
- * `--allow-protocol-change` is the flag that lets a CAPTURE_PROTOCOL_VERSION bump ship, invalidating
- * every cached capture. A typo silently means "do not allow", which is the safe direction — but
- * `--vm=` mistyped deploys to EVERY guest instead of the one named.
- *
- * An unrecognised flag is otherwise IGNORED, so it runs the default and reports success.
- */
-refuseUnknownFlags(["--vm=", "--allow-protocol-change"], { entry: import.meta.url, command: "npm run worker:deploy" });
+import { sandboxGitEnv } from "./src_git-safe-env_mjs.mjs";
+import { warnUtmDeprecated } from "./src_utm-deprecated_mjs.mjs";
+const MANIFEST_CASES = 1715;
+const CAPTURES_PER_CASE = 2;
+const RECAPTURE_COST = `${(MANIFEST_CASES * CAPTURES_PER_CASE).toLocaleString("en-US")} captures (${MANIFEST_CASES.toLocaleString("en-US")} cases in manifest.json x ${CAPTURES_PER_CASE}, read 2026-09-23T14:26Z; how long that takes depends on the fleet, so time a run rather than trust a figure)`;
+refuseUnknownFlags([
+    "--vm=",
+    "--allow-protocol-change"
+], {
+    entry: import.meta.url,
+    command: "npm run worker:deploy"
+});
 const run = promisify(execFile);
-// From the worker PACKAGE, not from the cwd. This was `resolve("src/capture/nvda")` and then
-// `resolve("packages/nvda-worker/src")` — a repo-layout guess that had to be edited every time the worker
-// moved, and that silently pointed at nothing whenever the cwd was not the repo root.
 const NVDA_DIR = workerSourceDir();
-// The guest's layout deliberately does NOT mirror the repo's. It is where provisioning put the files and
-// where the scheduled task points, so renaming it means re-provisioning every guest — and M5 moving the host
-// directory to `packages/nvda-worker/src` changed nothing here. All the worker needs is that its files land in
-// one directory together.
 const GUEST_DIR = "C:\\Users\\witness\\a11y-witness\\src\\capture\\nvda";
-// Resolved from THIS module: the fleet scripts ship with this package, so a cwd-relative path was only ever
-// right when run from the repo root.
 const CTL = fleetScriptPaths().workerCtl;
-const LIFECYCLE_TIMEOUT_MS = 420_000;
-// `pool` launches UTM if it is closed and polls every VM's /health. 90s was too short: it timed out
-// mid-deploy while three guests were transitioning, and the whole run died with a bare SIGTERM.
-const POOL_TIMEOUT_MS = 240_000;
-const HEALTH_TIMEOUT_MS = 20_000;
+const LIFECYCLE_TIMEOUT_MS = 420000;
+const POOL_TIMEOUT_MS = 240000;
+const deploy_worker_HEALTH_TIMEOUT_MS = 20000;
 const only = flagValue(process.argv, "vm");
-/**
- * The files that make up the worker's code version.
- *
- * Imported from the one module that defines them. This used to parse `check-worker-code.mjs`'s SOURCE with a
- * regex for the same list — better than a third copy, which is what the comment here used to argue, but it
- * still broke silently if that loop were ever rewritten, and "a file missing from the list deploys invisibly"
- * is the failure it was guarding against.
- */
 function hashedFiles() {
     return WORKER_FILES;
 }
-/**
- * The SHARED hasher, not a local copy of it.
- *
- * This used to hash raw bytes while `codeVersion()` normalises CRLF to LF -- and that difference is not
- * cosmetic: a worker whose repo was git-cloned on Windows checks out CRLF, so the two sides hashed
- * different bytes for identical code and the deploy verification reported STALE for ever. Measured on the
- * first bare-metal worker: 31979b551b7a2cfa against a checkout's 22822b7a3a08969c.
- *
- * `code-version.test.ts` claims to enforce "one hasher" but only greps for the file list, so this file
- * satisfied it while keeping its own implementation. Two implementations of a comparison are two chances
- * to disagree, and the whole point of this check is that both sides agree.
- */
 function localVersion() {
     return codeVersion(NVDA_DIR);
 }
 async function pool() {
-    const { stdout } = await run(CTL, ["pool"], { timeout: POOL_TIMEOUT_MS, encoding: "utf8" });
+    const { stdout } = await run(CTL, [
+        "pool"
+    ], {
+        timeout: POOL_TIMEOUT_MS,
+        encoding: "utf8"
+    });
     const all = JSON.parse(stdout);
-    return only ? all.filter((/** @type {{ name: string }} */ vm) => vm.name === only) : all;
+    return only ? all.filter((vm)=>vm.name === only) : all;
 }
-/** @param {string} action @param {string} vmName */
 function ctl(action, vmName) {
-    return run(CTL, [action], {
-        timeout: LIFECYCLE_TIMEOUT_MS, encoding: "utf8",
-        env: { ...process.env, A11Y_VM_NAME: vmName },
+    return run(CTL, [
+        action
+    ], {
+        timeout: LIFECYCLE_TIMEOUT_MS,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            A11Y_VM_NAME: vmName
+        }
     });
 }
-/**
- * Push one file. `utmctl file push` reads the content from stdin, which execFile cannot stream, so the
- * child is spawned and the file piped in.
- */
-/** @param {string} uuid @param {string} file @returns {Promise<void>} */
 function push(uuid, file) {
-    return new Promise((done, fail) => {
-        const child = execFile("utmctl", ["file", "push", uuid, `${GUEST_DIR}\\${file}`], (error) => error ? fail(new Error(`push ${file}: ${ /** @type {Error} */(error).message}`)) : done());
-        if (child.stdin)
-            createReadStream(resolve(NVDA_DIR, file)).pipe(child.stdin);
+    return new Promise((done, fail)=>{
+        const child = execFile("utmctl", [
+            "file",
+            "push",
+            uuid,
+            `${GUEST_DIR}\\${file}`
+        ], (error)=>error ? fail(new Error(`push ${file}: ${error.message}`)) : done());
+        if (child.stdin) createReadStream(external_node_path_resolve(NVDA_DIR, file)).pipe(child.stdin);
     });
 }
-/** @param {string} ip @param {number} port */
 async function healthCode(ip, port) {
-    // `requestJson`, not `fetch` -- audit §9's "the HTTP client" row: a second hand-rolled probe of the
-    // same worker JSON API, with its own timeout mechanism, buys nothing and carries `fetch`'s
-    // undifferentiated `TypeError: fetch failed` in place of a real error CODE (`ECONNREFUSED`,
-    // `EHOSTUNREACH`) -- the exact distinction `isTransient` and this repo's own diagnostics rely on
-    // elsewhere. This site was found by a tree-wide sweep, not the original audit's four named ones.
-    const response = await requestJson(`http://${ip}:${port}/health`, { timeoutMs: HEALTH_TIMEOUT_MS });
-    if (!response.ok)
-        throw new Error(`HTTP ${response.status} from /health`);
-    // `requestJson` returns `undefined` for unparseable JSON rather than throwing (its own docstring: a
-    // cache miss is a normal outcome for its usual callers) -- `fetch`'s `.json()` threw, and
-    // `healthCodeWhenAwake`'s retry loop relies on that to keep polling on garbage the same as on silence.
-    if (response.json === undefined)
-        throw new Error(`invalid JSON from http://${ip}:${port}/health`);
+    const response = await worker_http_requestJson(`http://${ip}:${port}/health`, {
+        timeoutMs: deploy_worker_HEALTH_TIMEOUT_MS
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status} from /health`);
+    if (void 0 === response.json) throw new Error(`invalid JSON from http://${ip}:${port}/health`);
     return response.json.code;
 }
-/** How long a rebooted guest gets to start answering before a deploy calls the verification failed. */
-const VERIFY_BUDGET_MS = 240_000;
-const VERIFY_POLL_MS = 10_000;
-/**
- * Read the guest's code hash, waiting for it to finish booting first.
- *
- * A guest that is not answering YET is not a failed deploy, and reading `/health` once immediately after the
- * reboot conflated the two: `worker:deploy` printed "stale or failed" while `npm run worker:code` — run a
- * minute later against the same guest — reported `matches`. That false alarm sent me redeploying guests that
- * had deployed correctly, repeatedly, and the deploy is the tool whose whole job is telling you whether the
- * push landed.
- *
- * Only SILENCE is waited on. A hash that answers and differs is returned straight to the caller, which
- * compares it — so a genuine stale deploy still fails immediately and only a booting guest costs time. Boot
- * times measured on this fleet run from 30 s to 147 s depending on how much Edge-profile hygiene the guest has
- * to do first, so the budget is well above the slowest honest answer.
- */
-/** @param {string} ip @param {number} port */
+const VERIFY_BUDGET_MS = 240000;
+const VERIFY_POLL_MS = 10000;
 async function healthCodeWhenAwake(ip, port) {
     const deadline = Date.now() + VERIFY_BUDGET_MS;
     let last = "no answer";
     let waited = false;
-    while (Date.now() < deadline) {
-        try {
-            const actual = await healthCode(ip, port);
-            if (waited)
-                process.stdout.write("\n");
-            return actual;
-        }
-        catch (error) {
-            last = error instanceof Error ? error.message : String(error);
-            if (!waited)
-                process.stdout.write("  waiting for the guest to answer /health ");
-            waited = true;
-            process.stdout.write(".");
-            await new Promise((resolve) => setTimeout(resolve, VERIFY_POLL_MS));
-        }
+    while(Date.now() < deadline)try {
+        const actual = await healthCode(ip, port);
+        if (waited) process.stdout.write("\n");
+        return actual;
+    } catch (error) {
+        last = error instanceof Error ? error.message : String(error);
+        if (!waited) process.stdout.write("  waiting for the guest to answer /health ");
+        waited = true;
+        process.stdout.write(".");
+        await new Promise((resolve)=>setTimeout(resolve, VERIFY_POLL_MS));
     }
-    if (waited)
-        process.stdout.write("\n");
+    if (waited) process.stdout.write("\n");
     throw new Error(`${ip}:${port} never answered /health within ${VERIFY_BUDGET_MS / 1000}s (last: ${last})`);
 }
-/**
- * Wait until a VM is no longer `stopping`, so the next deploy does not start a guest on top of one still
- * holding its memory.
- *
- * Bounded and non-fatal: if it never settles we continue and let the next deploy report its own failure,
- * because a deploy that hangs forever is worse than one that reports a stale worker.
- */
-/** @param {string} name @param {number} [limitMs] */
-async function waitUntilSettled(name, limitMs = 120_000) {
+async function waitUntilSettled(name, limitMs = 120000) {
     const deadline = Date.now() + limitMs;
-    while (Date.now() < deadline) {
-        const vm = (await pool()).find((/** @type {{ name: string }} */ v) => v.name === name);
-        if (!vm || vm.state !== "stopping")
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 5_000));
+    while(Date.now() < deadline){
+        const vm = (await pool()).find((v)=>v.name === name);
+        if (!vm || "stopping" !== vm.state) return;
+        await new Promise((resolve)=>setTimeout(resolve, 5000));
     }
     process.stdout.write(`  note: ${name} is still stopping; continuing anyway\n`);
 }
-/** @param {Record<string, any>} vm @param {string[]} files @param {string} expected */
 async function deployTo(vm, files, expected) {
     process.stdout.write(`\n=== ${vm.name} ===\n`);
-    // Push needs the guest running; the reboot afterwards is what actually loads the new code.
     await ctl("up", vm.name);
-    for (const file of files) {
+    for (const file of files){
         await push(vm.uuid, file);
         process.stdout.write(`  pushed ${file}\n`);
     }
     process.stdout.write("  rebooting (utmctl exec cannot be trusted to restart the worker) ...\n");
     await ctl("stop", vm.name);
     await ctl("up", vm.name);
-    // The restore is in a `finally` because it used to be on the SUCCESS path only, and the failure path is
-    // exactly when it matters. A guest whose health check threw was left RUNNING, and the loop then started
-    // the next VM on top of it — on a host `doctor` reports as having room for one of two, that guarantees
-    // the second times out too. It is then printed as "stale or failed", which reads as a broken guest and
-    // sent me looking to rebuild one that boots to ready in 33 s.
     try {
         const fresh = await pool();
-        const back = fresh.find((/** @type {{ name: string }} */ v) => v.name === vm.name);
-        if (!back?.ip)
-            throw new Error(`${vm.name} did not come back with an address`);
+        const back = fresh.find((v)=>v.name === vm.name);
+        if (!back?.ip) throw new Error(`${vm.name} did not come back with an address`);
         const actual = await healthCodeWhenAwake(back.ip, back.port);
         const ok = actual === expected;
         process.stdout.write(`  /health.code ${actual} ${ok ? "== expected" : `!= expected ${expected}`}\n`);
         return ok;
-    }
-    finally {
-        // Put it back where it was found, the same contract the run's lease honours.
-        if (vm.state !== "started")
-            await ctl("stop", vm.name).catch(() => undefined);
+    } finally{
+        if ("started" !== vm.state) await ctl("stop", vm.name).catch(()=>void 0);
     }
 }
-/**
- * Refuse to deploy a CAPTURE_PROTOCOL_VERSION change unless it is asked for explicitly.
- *
- * This deploys the WORKING TREE, which is right for testing a change and dangerous for one specific
- * change: the protocol version is a capture-cache key input, so shipping a bump invalidates every capture
- * on disk and forces a full recapture (`RECAPTURE_COST`, in protocol-guard.mjs, says how big).
- *
- * The trap is real and was live in this repo. An uncommitted bump in a shared checkout makes
- * `npm run worker:code` report every worker STALE, and the remedy it prints is "redeploy" — which would
- * deploy the bump, wipe the cache, and give no clue why the next run recaptured everything.
- */
 function guardProtocolChange() {
-    const inTree = String(PROTOCOL_IN_TREE);
+    const inTree = String(CAPTURE_PROTOCOL_VERSION);
     let committed;
     try {
-        committed = /CAPTURE_PROTOCOL_VERSION = (\d+)/.exec(execFileSync("git", ["-C", NVDA_DIR, "show", "HEAD:./protocol-version.mjs"], { encoding: "utf8", env: sandboxGitEnv() }))?.[1];
-    }
-    catch {
-        // Two very different situations, and one of them is a guard that has quietly stopped guarding: there may
-        // be no git checkout at all, or the PATH may have moved (M5 relocated this file from `src/capture/nvda/`;
-        // it moved AGAIN out of `capture-core.mjs` into its own file on architecture-audit.md §5, item 3) so
-        // `git show` finds nothing. The second would silently disable the most expensive check in this script,
-        // which is exactly the shape this repo keeps paying for, so it says so.
+        committed = /CAPTURE_PROTOCOL_VERSION = (\d+)/.exec(execFileSync("git", [
+            "-C",
+            NVDA_DIR,
+            "show",
+            "HEAD:./protocol-version.mjs"
+        ], {
+            encoding: "utf8",
+            env: sandboxGitEnv()
+        }))?.[1];
+    } catch  {
         try {
-            execFileSync("git", ["rev-parse", "--verify", "HEAD"], { stdio: "ignore", env: sandboxGitEnv() });
-            process.stdout.write("  note: cannot compare CAPTURE_PROTOCOL_VERSION against HEAD — "
-                + `${resolve(NVDA_DIR, "protocol-version.mjs")} is not in HEAD.\n`
-                + "        Expected for a brand-new or just-moved file; if the path moved, fix it here or this guard is off.\n");
-        }
-        catch { /* genuinely not a git checkout: nothing to compare, and nothing to warn about */ }
-        return;
-    }
-    if (!inTree || !committed || inTree === committed)
-        return;
-    if (process.argv.includes("--allow-protocol-change")) {
-        process.stdout.write(`\nDeploying CAPTURE_PROTOCOL_VERSION ${committed} -> ${inTree} as requested. ` +
-            "Every cached capture is now invalid and the next run will recapture all of them.\n");
+            execFileSync("git", [
+                "rev-parse",
+                "--verify",
+                "HEAD"
+            ], {
+                stdio: "ignore",
+                env: sandboxGitEnv()
+            });
+            process.stdout.write(`  note: cannot compare CAPTURE_PROTOCOL_VERSION against HEAD — ${external_node_path_resolve(NVDA_DIR, "protocol-version.mjs")} is not in HEAD.\n        Expected for a brand-new or just-moved file; if the path moved, fix it here or this guard is off.\n`);
+        } catch  {}
         return;
     }
-    process.stderr.write(`\nREFUSING TO DEPLOY: the working tree has CAPTURE_PROTOCOL_VERSION = ${inTree}, but HEAD has ` +
-        `${committed}.\n\n` +
-        "That value is a capture-cache key, so deploying it invalidates all cached captures and forces a\n" +
-        `full recapture: ${RECAPTURE_COST}. If a \`worker:code\` STALE report sent you here, the stale\n` +
-        "hash is probably caused by this uncommitted bump rather than by the guests being out of date.\n\n" +
-        "  git stash                            # deploy without the bump, or\n" +
-        "  npm run worker:deploy -- --allow-protocol-change   # deploy it deliberately\n");
+    if (!inTree || !committed || inTree === committed) return;
+    if (process.argv.includes("--allow-protocol-change")) return void process.stdout.write(`\nDeploying CAPTURE_PROTOCOL_VERSION ${committed} -> ${inTree} as requested. Every cached capture is now invalid and the next run will recapture all of them.\n`);
+    process.stderr.write(`\nREFUSING TO DEPLOY: the working tree has CAPTURE_PROTOCOL_VERSION = ${inTree}, but HEAD has ${committed}.\n\nThat value is a capture-cache key, so deploying it invalidates all cached captures and forces a\nfull recapture: ${RECAPTURE_COST}. If a \`worker:code\` STALE report sent you here, the stale\nhash is probably caused by this uncommitted bump rather than by the guests being out of date.\n\n  git stash                            # deploy without the bump, or\n  npm run worker:deploy -- --allow-protocol-change   # deploy it deliberately\n`);
     process.exit(3);
 }
-/**
- * Nothing here runs on import.
- *
- * This module used to execute its whole deploy at module scope, so merely importing it — which I did, to read a
- * path constant — ran `guardProtocolChange()` and began enumerating VMs. With guests running it would have
- * pushed files and rebooted them. A program that reboots machines must be invoked, never merely mentioned.
- *
- * `check-worker-code.mjs` got the same treatment. The four remaining scripts in this repo that execute at
- * module scope are pure programs nothing imports; they are left alone deliberately rather than restructured for
- * symmetry.
- */
 async function main() {
     warnUtmDeprecated("npm run worker:deploy");
     guardProtocolChange();
@@ -303,18 +173,13 @@ async function main() {
     process.stdout.write(`Deploying ${files.length} file(s) to ${vms.length} worker(s)\n`);
     process.stdout.write(`Files: ${files.join(", ")}\nExpected code: ${expected}\n`);
     const failed = [];
-    for (const vm of vms) {
+    for (const vm of vms){
         try {
-            if (!await deployTo(vm, files, expected))
-                failed.push(vm.name);
-        }
-        catch (error) {
-            process.stdout.write(`  FAILED: ${ /** @type {Error} */(error).message}\n`);
+            if (!await deployTo(vm, files, expected)) failed.push(vm.name);
+        } catch (error) {
+            process.stdout.write(`  FAILED: ${error.message}\n`);
             failed.push(vm.name);
         }
-        // A `stop` returns before the guest has actually released its memory — one was observed sitting in
-        // `stopping` for minutes. Starting the next VM into that overlap is the same over-commitment by a
-        // second route, so wait for the host to be quiet before moving on.
         await waitUntilSettled(vm.name);
     }
     process.stdout.write(`\n${vms.length - failed.length}/${vms.length} worker(s) on ${expected}\n`);
@@ -324,10 +189,4 @@ async function main() {
     }
     process.exit(failed.length ? 1 : 0);
 }
-// REALPATH'D: `import.meta.url` is resolved through symlinks by Node's ESM loader and `process.argv[1]`
-// is not, so a bin reached via its `.bin` symlink (which is how npm always installs one) mismatched here
-// and this guard silently read false — the tool loaded, did nothing, and exited 0. `/var` and `/tmp` are
-// themselves symlinks on macOS, so this fired every time. Same defect, same fix, as `cli.ts`'s `isProgram`.
-if (import.meta.url === pathToFileURL(process.argv[1] ? realpathSync(process.argv[1]) : "").href)
-    await main();
-//# sourceMappingURL=deploy-worker.mjs.map
+if (import.meta.url === pathToFileURL(process.argv[1] ? realpathSync(process.argv[1]) : "").href) await main();

package/dist/doctor.d.mts

@@ -213,4 +213,3 @@ export function addCheck(name: string, ok: boolean, detail: string, remedy?: str
 }): void;
 export function allChecks(): string[];
 export function gatingChecks(): string[];
-//# sourceMappingURL=doctor.d.mts.map